diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c8e3c8b4a..d25e20071 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -60,6 +60,11 @@ jobs: - name: Check codegen'd IxVM kernel is up to date if: github.event_name != 'push' run: lake exe ix codegen --check + # A stale generated trace module is otherwise caught only when the + # generated GPU provider registers at proving time. + - name: Check generated trace writers, CUDA units and manifest are up to date + if: github.event_name != 'push' + run: lake exe ix codegen --trace-bundle --check - name: Check Lean versions match for Ix and compiler bench if: github.event_name != 'push' run: diff lean-toolchain Benchmarks/Compile/lean-toolchain diff --git a/Cargo.lock b/Cargo.lock index f3d97945e..05ea7dbe5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -51,6 +51,7 @@ name = "aiur" version = "0.1.0" dependencies = [ "bincode", + "blake3", "hashbrown 0.15.5", "indexmap", "libc", @@ -61,6 +62,7 @@ dependencies = [ "p3-symmetric", "rayon", "rustc-hash", + "serde_json", "tracing", "tracing-texray", ] @@ -847,7 +849,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.59.0", ] [[package]] @@ -1252,6 +1254,15 @@ dependencies = [ "tracing", ] +[[package]] +name = "home" +version = "0.5.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "http" version = "1.4.0" @@ -1972,6 +1983,12 @@ dependencies = [ "cc", ] +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + [[package]] name = "linux-raw-sys" version = "0.12.1" @@ -2108,7 +2125,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=a155ee47687e3a9b7e94f158eeff9d710a8262d5#a155ee47687e3a9b7e94f158eeff9d710a8262d5" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=acfc370a2e74affcb7e8ee218fbbaf80b9da1eef#acfc370a2e74affcb7e8ee218fbbaf80b9da1eef" dependencies = [ "bincode", "itertools 0.14.0", @@ -2128,6 +2145,7 @@ dependencies = [ "p3-util", "rayon", "serde", + "sppark", "tracing", ] @@ -2382,7 +2400,7 @@ version = "0.50.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" dependencies = [ - "windows-sys 0.61.2", + "windows-sys 0.59.0", ] [[package]] @@ -3350,6 +3368,19 @@ dependencies = [ "semver", ] +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + [[package]] name = "rustix" version = "1.1.4" @@ -3359,8 +3390,8 @@ dependencies = [ "bitflags", "errno", "libc", - "linux-raw-sys", - "windows-sys 0.61.2", + "linux-raw-sys 0.12.1", + "windows-sys 0.59.0", ] [[package]] @@ -3430,7 +3461,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b55fb86dfd3a2f5f76ea78310a88f96c4ea21a3031f8d212443d56123fd0521" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.59.0", ] [[package]] @@ -3663,6 +3694,15 @@ dependencies = [ "der", ] +[[package]] +name = "sppark" +version = "0.1.15" +source = "git+https://github.com/argumentcomputer/sppark?rev=e10e107673aa22861f0f8b9758fc62169ab919ae#e10e107673aa22861f0f8b9758fc62169ab919ae" +dependencies = [ + "cc", + "which", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -3758,8 +3798,8 @@ version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874" dependencies = [ - "rustix", - "windows-sys 0.61.2", + "rustix 1.1.4", + "windows-sys 0.59.0", ] [[package]] @@ -4405,6 +4445,18 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "which" +version = "4.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" +dependencies = [ + "either", + "home", + "once_cell", + "rustix 0.38.44", +] + [[package]] name = "widestring" version = "1.2.1" diff --git a/Cargo.toml b/Cargo.toml index 6512d0974..38c2eed94 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -53,7 +53,7 @@ log = "0.4" memmap2 = "0.9" # Bundle v3.5.1 to fix large-arena failures (microsoft/mimalloc#1309). mimalloc = { git = "https://github.com/argumentcomputer/mimalloc_rust.git", rev = "616cc1f130d9ea2a1111a46b4e98c140e078f882", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "a155ee47687e3a9b7e94f158eeff9d710a8262d5" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "acfc370a2e74affcb7e8ee218fbbaf80b9da1eef" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" diff --git a/Ix/Aggr/FFI.lean b/Ix/Aggr/FFI.lean index 0dda3057f..984c02bf0 100644 --- a/Ix/Aggr/FFI.lean +++ b/Ix/Aggr/FFI.lean @@ -97,6 +97,33 @@ opaque aggregateExpected (envHandle : @& EnvHandle) Except String AggregateExpected + +/-- The Stage 2 plan cut for `ix prove --lanes`: the tree is split from the +root while any frontier node holds more than `subtreeSize` leaves (a lone +leaf may then stand as a subtree of its own). Rows in post-order: +`#[0, slot, ids…]` for a subtree (its root slot, as `ix aggregate --subtree` +numbers slots, then the manifest ids of the shards under it, sorted) and +`#[1, slot, left, right]` for each join above the frontier, the root +last. -/ +@[extern "rs_aiur_aggregate_subtree_plan"] +opaque aggregateSubtreePlan (envHandle : @& EnvHandle) (manifestPath : @& String) + (structuralAbove subtreeSize : @& Nat) : Except String (Array (Array Nat)) + +/-- `ix prove --lanes`: the whole multi-device run in this process, one +resident prover per GPU built from these two systems (`AiurSystem.on_device` +in Rust; nothing is copied across the FFI), every claim and join scheduled +over them as their inputs become ready, the root wrapped, and every claim +proof verified natively at the end. `maxRamBytes` is one worker's host +budget (0 detects); `execJobs` the claim executions ahead of each prover. +Oversized environment claims are bisected and checkpointed; completed +proofs are reused. A nonempty `outManifest` receives the final partition. +Returns the verified root address; progress is printed on stderr. -/ +@[extern "rs_aiur_prove_lanes"] +opaque proveLanes (ixvmSystem aggrSystem : @& AiurSystem) + (envHandle : @& EnvHandle) (manifestPath : @& String) + (verifyIdx aggrIdx lanes maxRamBytes execJobs structuralAbove : @& Nat) + (cacheFriBytes : @& ByteArray) (outManifest : @& String) : Except String String + end AiurSystem end Aiur end diff --git a/Ix/Aiur/Codegen/Rust.lean b/Ix/Aiur/Codegen/Rust.lean index ba864d6e4..a10adfe05 100644 --- a/Ix/Aiur/Codegen/Rust.lean +++ b/Ix/Aiur/Codegen/Rust.lean @@ -35,6 +35,7 @@ inductive MatchPat where | litU64 (n : Nat) | wildcard | tuple (elems : Array MatchPat) + | array (elems : Array MatchPat) | constructor (path : Array String) (args : Array MatchPat) deriving Inhabited, BEq @@ -73,6 +74,7 @@ inductive RustExpr where inductive RustStmt where | letStmt (isMut : Bool) (name : String) (ty : Option RustType) (val : RustExpr) | letPattern (pat : MatchPat) (ty : Option RustType) (val : RustExpr) + | assign (target : RustExpr) (val : RustExpr) | exprStmt (e : RustExpr) | returnStmt (e : RustExpr) | ifStmt (cond : RustExpr) (thenStmts : Array RustStmt) @@ -143,6 +145,7 @@ partial def MatchPat.toStr : MatchPat → String | .litU64 n => s!"{n}u64" | .wildcard => "_" | .tuple ps => tupleText (ps.map MatchPat.toStr) + | .array ps => "[" ++ commaSep (ps.map MatchPat.toStr) ++ "]" | .constructor path ps => "::".intercalate path.toList ++ "(" ++ commaSep (ps.map MatchPat.toStr) ++ ")" @@ -167,11 +170,11 @@ partial def RustExpr.toStr : RustExpr → String let callee := match f with | .field .. => "(" ++ f.toStr ++ ")" | _ => f.postfixBase - callee ++ "(" ++ commaSep (xs.map (·.toStr)) ++ ")" + callee ++ "(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" | .methodCall e n xs => e.postfixBase ++ "." ++ n ++ - "(" ++ commaSep (xs.map (·.toStr)) ++ ")" + "(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" | .constGeneric f xs => f.postfixBase ++ "::<" ++ commaSep (xs.map (·.toStr)) ++ ">" - | .index a i => a.postfixBase ++ "[" ++ i.toStr ++ "]" + | .index a i => a.postfixBase ++ "[" ++ i.toStrBare ++ "]" | .field e n => e.postfixBase ++ "." ++ n | .binop op a b => "(" ++ a.toStr ++ " " ++ op.toStr ++ " " ++ b.toStr ++ ")" -- Parenthesize prefix/cast expressions so postfix composition preserves precedence. @@ -182,12 +185,12 @@ partial def RustExpr.toStr : RustExpr → String | .tryExpr e => e.postfixBase ++ "?" | .range a b => (a.map (·.toStr) |>.getD "") ++ ".." ++ (b.map (·.toStr) |>.getD "") - | .macroCall n xs => n ++ "!(" ++ commaSep (xs.map (·.toStr)) ++ ")" - | .arrayLit xs => "[" ++ commaSep (xs.map (·.toStr)) ++ "]" - | .arrayRepeat e n => "[" ++ e.toStr ++ "; " ++ n.toStr ++ "]" - | .tuple xs => tupleText (xs.map (·.toStr)) + | .macroCall n xs => n ++ "!(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" + | .arrayLit xs => "[" ++ commaSep (xs.map (·.toStrBare)) ++ "]" + | .arrayRepeat e n => "[" ++ e.toStrBare ++ "; " ++ n.toStr ++ "]" + | .tuple xs => tupleText (xs.map (·.toStrBare)) | .structLit p fs => "::".intercalate p.toList ++ " { " ++ - commaSep (fs.map fun (n, e) => n ++ ": " ++ e.toStr) ++ " }" + commaSep (fs.map fun (n, e) => n ++ ": " ++ e.toStrBare) ++ " }" | .block b => b.toStr | .unsafeBlock b => "unsafe " ++ b.toStr | .labeledBlock label b => "'" ++ label ++ ": " ++ b.toStr @@ -202,13 +205,24 @@ partial def RustExpr.postfixBase (e : RustExpr) : String := | .closure .. | .ifExpr .. | .matchExpr .. | .range .. => "(" ++ e.toStr ++ ")" | _ => e.toStr +/-- An expression in a position the grammar already delimits (an argument, + an element, an index, an initializer), where its own parentheses would + be redundant and trip the lints. -/ +partial def RustExpr.toStrBare : RustExpr → String + | .binop op a b => a.toStr ++ " " ++ op.toStr ++ " " ++ b.toStr + | .deref e => "*" ++ e.toStr + | .ref e => "&" ++ e.toStr + | .not e => "!" ++ e.toStr + | .cast e t => e.toStr ++ " as " ++ t.toStr + | e => e.toStr + /-- Generated source stays compact: whitespace separates tokens, but nested syntax never expands into additional lines. Each top-level item gets one line. String contents are escaped before rendering, not whitespace-stripped. -/ partial def RustBlock.toStr (b : RustBlock) : String := "{ " ++ stmtsToStr b.stmts ++ (if b.stmts.isEmpty then "" else " ") ++ - (b.tail.map RustExpr.toStr |>.getD "") ++ " }" + (b.tail.map RustExpr.toStrBare |>.getD "") ++ " }" partial def renderMatch (scrut : RustExpr) (arms : Array MatchArm) : String := "match " ++ scrut.toStr ++ " { " ++ @@ -219,11 +233,13 @@ partial def renderMatch (scrut : RustExpr) (arms : Array MatchArm) : String := partial def RustStmt.toStr : RustStmt → String | .letStmt isMut n ty e => "let " ++ (if isMut then "mut " else "") ++ n ++ - (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStr ++ ";" + (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStrBare ++ ";" | .letPattern p ty e => "let " ++ p.toStr ++ - (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStr ++ ";" - | .exprStmt e => e.toStr ++ ";" - | .returnStmt e => "return " ++ e.toStr ++ ";" + (ty.map (fun t => ": " ++ t.toStr) |>.getD "") ++ " = " ++ e.toStrBare ++ ";" + | .assign t e => t.toStr ++ " = " ++ e.toStrBare ++ ";" + | .exprStmt e => e.toStrBare ++ ";" + | .returnStmt (.tuple #[]) => "return;" + | .returnStmt e => "return " ++ e.toStrBare ++ ";" | .ifStmt c t e => "if " ++ c.toStr ++ " " ++ RustBlock.toStr { stmts := t } ++ (e.map (fun ss => " else " ++ RustBlock.toStr { stmts := ss }) |>.getD "") @@ -231,7 +247,7 @@ partial def RustStmt.toStr : RustStmt → String | .block ss => RustBlock.toStr { stmts := ss } | .forStmt p e ss => "for " ++ p.toStr ++ " in " ++ e.toStr ++ " " ++ RustBlock.toStr { stmts := ss } - | .breakWith label e => "break '" ++ label ++ " " ++ e.toStr ++ ";" + | .breakWith label e => "break '" ++ label ++ " " ++ e.toStrBare ++ ";" partial def stmtsToStr (ss : Array RustStmt) : String := " ".intercalate (ss.toList.map RustStmt.toStr) @@ -243,10 +259,12 @@ def RustItem.toStr : RustItem → String let vis := match f.visibility with | .internal => "" | .crate => "pub(crate) " let generics := if f.constParams.isEmpty then "" else "<" ++ commaSep (f.constParams.map fun (n, t) => "const " ++ n ++ ": " ++ t.toStr) ++ ">" + -- A unit return type is left implicit, as the lints prefer. + let returns := if f.returnTy == .tuple #[] then "" else "-> " ++ f.returnTy.toStr ++ " " vis ++ "fn " ++ f.name ++ generics ++ "(" ++ commaSep (f.params.map fun (n, t) => n ++ ": " ++ t.toStr) ++ (if f.params.isEmpty then "" else ",") ++ - ") -> " ++ f.returnTy.toStr ++ " " ++ f.body.toStr ++ "\n" + ") " ++ returns ++ f.body.toStr ++ "\n" end Aiur.Codegen end diff --git a/Ix/Aiur/Stages/TraceCodegen.lean b/Ix/Aiur/Stages/TraceCodegen.lean new file mode 100644 index 000000000..dbad753d0 --- /dev/null +++ b/Ix/Aiur/Stages/TraceCodegen.lean @@ -0,0 +1,385 @@ +module + +public import Ix.Aiur.Stages.Codegen +public import Ix.Aiur.Stages.TracePlan +public import Ix.Aiur.Stages.TraceContract + +public section + +namespace Aiur.TraceCodegen + +open Bytecode TracePlan Codegen + +private inductive Mode where + | row | pack | typed + deriving BEq + +private def setter : SeedWidth → String + | .u8 => "u8" | .u16 => "u16" | .u32 => "u32" | .full => "full" + +private def widthLiteral : SeedWidth → String + | .u8 => "SeedWidth::U8" | .u16 => "SeedWidth::U16" + | .u32 => "SeedWidth::U32" | .full => "SeedWidth::Full" + +private def gOne : RustExpr := .path #["G", "ONE"] +private def gTy : RustType := .named "G" +private def gArray (n : Nat) : RustType := .array gTy (.value n) +private def u64Slice (mutable : Bool) : RustType := .ref mutable (.slice (.named "u64")) +private def unit : RustExpr := .tuple #[] +private def valueExpr (id : ValueId) : RustExpr := .var s!"v_{id}" +/-- A call of a free function or associated function named by its path. -/ +private def call (path : String) (args : Array RustExpr) : RustExpr := + .call (.path (path.splitOn "::").toArray) args +private def method (value : RustExpr) (name : String) (args : Array RustExpr := #[]) : RustExpr := + .methodCall value name args +private def canonical (value : RustExpr) : RustExpr := method value "as_canonical_u64" +private def indexExpr (name : String) (index : Nat) : RustExpr := .index (.var name) (.nat index) +private def declaration (name : String) (value : RustExpr) : RustStmt := .letStmt false name none value +/-- `let [v_a, v_b]: [G; 2] = value;` -/ +private def destructure (ids : Array ValueId) (value : RustExpr) : RustStmt := + .letPattern (.array (ids.map fun id => .binding s!"v_{id}")) (some (gArray ids.size)) value +private def ok : RustStmt := .returnStmt (call "Ok" #[unit]) + +private def Mode.operations (mode : Mode) (plan : FunctionPlan) : Array Nat := + match mode with + | .row => plan.rowOperations + | .pack | .typed => plan.preparationOperations + +private def Mode.values (mode : Mode) (plan : FunctionPlan) : Array ValueId := + match mode with + | .row => plan.rowValues + | .pack | .typed => plan.preparationValues + +private def rowWrite (region : String) (index : Nat) (value : RustExpr) : RustStmt := + let base := RustExpr.field (.var "offsets") region + let column := if index == 0 then base else .binop .add base (.nat index) + .assign (.index (.var "row") column) (canonical value) + +private def readExpression (op : Operation) (read : ExternalRead) : RustExpr := + let args := op.inputs.map valueExpr + let site := RustExpr.nat op.index + -- `context.::(…)`: the reads that size their result by the + -- operation's output count. + let sized := fun (name : String) (params : Array RustExpr) => + RustExpr.call (.constGeneric (.field (.var "context") name) #[.nat op.outputs.size]) params + let plain := fun (name : String) (params : Array RustExpr) => method (.var "context") name params + .tryExpr <| match read.kind with + | .callResult callee => sized "call" #[site, .nat callee, .ref (.arrayLit args)] + | .returnedCall _ => sized "returned" #[site] + | .storePointer _ => plain "store" #[site, .ref (.arrayLit args)] + | .loadValues _ => sized "load" #[site, args[0]!] + | .ioInfo => plain "io_info" #[site, args[0]!, .ref (.arrayLit (args.extract 1 args.size))] + | .ioValues _ => sized "io_read" #[site, args[0]!, args[1]!] + | .bigUintResults => plain "big_uint" #[site, args[0]!, args[1]!] + +private def emitOperation (plan : FunctionPlan) (mode : Mode) (op : Operation) : Except String (Array RustStmt) := do + let inputs := op.inputs.map valueExpr + let a := inputs[0]?.getD gZero + let b := inputs[1]?.getD gZero + let unary := fun name => call name #[.ref a] + let binary := fun name => call name #[.ref a, .ref b] + let single := fun value => RustExpr.arrayLit #[value] + let temp := s!"op_{op.index}" + let mut stmts := #[] + let mut auxiliary : Option (Array RustExpr) := none + let expression ← match op.externalRead with + | some read => + if mode == .row then + pure (.arrayLit ((Array.range read.seed.size).map fun i => + call "G::from_u64" #[indexExpr "seed" (read.seed.start + i)])) + else pure (readExpression op read) + | none => + match op.opcode with + | .const value => pure (single (gFromU64 value.n)) + | .add .. => pure (single (.binop .add a b)) + | .sub .. => pure (single (.binop .sub a b)) + | .mul .. => pure (single (.binop .mul a b)) + | .eqZero .. => + if op.auxiliaries.size != 0 then + auxiliary := some #[call "g_inverse_value" #[a], valueExpr op.outputs[0]!] + pure (single (gFromBool (method a "is_zero"))) + | .unconstrainedGInverse .. => pure (single (call "g_inverse_value" #[a])) + | .unconstrainedGToBytes .. => + pure (method (method (canonical a) "to_le_bytes") "map" #[.path #["G", "from_u8"]]) + | .u8BitDecomposition .. => + pure (.arrayLit ((Array.range 8).map fun i => + let shifted := if i == 0 then canonical a else .binop .shr (canonical a) (.nat i) + gFromBool (.binop .ne (.binop .bitAnd shifted (.nat 1)) (.nat 0)))) + | .u8ShiftLeft .. => pure (single (unary "Bytes1::shift_left")) + | .u8ShiftRight .. => pure (single (unary "Bytes1::shift_right")) + | .u8Xor .. => pure (single (binary "Bytes2::xor")) + | .u8And .. => pure (single (binary "Bytes2::and")) + | .u8Or .. => pure (single (binary "Bytes2::or")) + | .u8LessThan .. => pure (single (binary "Bytes2::less_than")) + | .u8Add .. | .u8Sub .. | .u8Mul .. | .u8XorSplit4 .. | .u8XorSplit7 .. => + let name := match op.opcode with + | .u8Add .. => "add" | .u8Sub .. => "sub" | .u8Mul .. => "mul" + | .u8XorSplit4 .. => "xor_split4" | _ => "xor_split7" + stmts := stmts.push (declaration temp (binary s!"Bytes2::{name}")) + pure (.arrayLit #[.field (.var temp) "0", .field (.var temp) "1"]) + | .u32LessThan .. => + stmts := stmts.push (declaration temp (call "u32_less_than" #[a, b])) + auxiliary := some ((Array.range 6).map fun i => .index (.field (.var temp) "1") (.nat i)) + pure (single (.field (.var temp) "0")) + | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. => + let words := (Array.range (inputs.size / 4)).map fun i => + call "u32_word" #[.arrayLit (inputs.extract (4*i) (4*i+4))] + pure (call "u32_add" #[.ref (.arrayLit words)]) + | .u32ToField .. => pure (single (call "G::from_u64" #[call "u32_word" #[.arrayLit inputs]])) + | .assertEq .. | .ioSetInfo .. | .ioWrite .. | .debug .. | .u8RangeCheck .. => + pure (.arrayLit #[]) + | .call .. | .load .. | .ioRead .. => + if op.outputs.isEmpty then pure (.arrayLit #[]) + else throw s!"operation {op.index}: missing external read" + | .store .. | .ioGetInfo .. | .unconstrainedBigUintDivMod .. => + throw s!"operation {op.index}: missing external read" + if !op.outputs.isEmpty then + stmts := stmts.push (destructure op.outputs expression) + if mode == .row then + let columns := auxiliary.getD ((op.outputs.extract 0 op.auxiliaries.size).map valueExpr) + unless columns.size == op.auxiliaries.size do + throw s!"operation {op.index}: scalar writer auxiliary count differs from plan" + for i in [:columns.size] do + stmts := stmts.push (rowWrite "auxiliaries" (op.auxiliaries.start + i) columns[i]!) + else if let some read := op.externalRead then + for i in [:op.outputs.size] do + if mode == .typed then + let slot := read.seed.start + i + let width := plan.seedSchema.widths[slot]?.getD .full + let offset := plan.seedSchema.offsets[slot]?.getD (8 * slot) + stmts := stmts.push (.exprStmt (method (.var "seed") (setter width) #[.nat offset, valueExpr op.outputs[i]!])) + else + stmts := stmts.push (.assign (indexExpr "seed" (read.seed.start + i)) (canonical (valueExpr op.outputs[i]!))) + pure stmts + +private structure YieldTarget where + label : String + indices : Array Nat + +mutual + private partial def emitBlock (plan : FunctionPlan) (mode : Mode) (block : BlockPlan) + (target : Option YieldTarget) (depth : Nat) : Except String (Array RustStmt) := do + let mut result := #[] + for index in block.operations do + if (mode.operations plan).contains index then + let some operation := plan.operations[index]? | throw "missing planned operation" + result := result ++ (← emitOperation plan mode operation) + pure (result ++ (← emitControl plan mode block.control target depth)) + + private partial def emitArms (plan : FunctionPlan) (mode : Mode) (discriminant : ValueId) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (inverses : Span) + (target : Option YieldTarget) (depth : Nat) : Except String RustStmt := do + let mut result : Array MatchArm := #[] + for (value, block) in arms do + result := result.push { + pat := .litU64 value.n + body := { stmts := ← emitBlock plan mode block target depth } } + let defaultBody ← match fallback with + | none => pure #[.returnStmt (call "Err" #[call "no_match" #[.nat plan.index, valueExpr discriminant]])] + | some block => do + let mut writes := #[] + if mode == .row then + for ((value, _), i) in arms.zipIdx do + let difference := RustExpr.binop .sub (valueExpr discriminant) (gFromU64 value.n) + writes := writes.push (rowWrite "auxiliaries" (inverses.start + i) (method difference "inverse")) + pure (writes ++ (← emitBlock plan mode block target depth)) + result := result.push { pat := .wildcard, body := { stmts := defaultBody } } + pure (.matchStmt (canonical (valueExpr discriminant)) result) + + private partial def emitControl (plan : FunctionPlan) (mode : Mode) (control : Control) + (target : Option YieldTarget) (depth : Nat) : Except String (Array RustStmt) := do + let selector := fun index => if mode == .row then #[rowWrite "selectors" index gOne] else #[] + match control with + | .returnRow index _ => pure (selector index |>.push ok) + | .yieldRow index ids => + let some target := target | throw "yield has no scalar continuation" + pure (selector index |>.push (.breakWith target.label (.arrayLit (target.indices.map fun i => valueExpr ids[i]!)))) + | .branch discriminant arms fallback inverses _ => + if mode != .row && !(mode.values plan).contains discriminant then return #[ok] + pure #[← emitArms plan mode discriminant arms fallback inverses target depth] + | .continueWith discriminant arms fallback inverses _ merges columns continuation => + if mode != .row && !(mode.values plan).contains discriminant then return #[ok] + let indices := (Array.range merges.size).filter fun i => mode == .row || (mode.values plan).contains merges[i]! + let label := s!"yield_{depth}" + let body ← emitArms plan mode discriminant arms fallback inverses (some ⟨label, indices⟩) (depth + 1) + let merged := indices.map fun i => merges[i]! + let mut result := #[destructure merged (.labeledBlock label { stmts := #[body] })] + if mode == .row then + for i in [:merges.size] do + result := result.push (rowWrite "auxiliaries" (columns.start + i) (valueExpr merges[i]!)) + pure (result ++ (← emitBlock plan mode continuation target depth)) +end + +/-- Every path through a writer ends in `return Ok(())`, a yield or a +`no_match` error. Rust's lints want the function's last statement as a +tail expression, so the final return of the body and of every arm of a +final `match` becomes one. A writer that never fails (no fallible read, no +unmatched discriminant) returns `()` instead, its remaining returns bare. -/ +private partial def tailReturns (fallible : Bool) (stmts : Array RustStmt) : RustBlock := + match stmts.back? with + | some (.returnStmt e) => { stmts := stmts.pop, tail := if fallible then some e else none } + | some (.matchStmt scrutinee arms) => + { stmts := stmts.pop + tail := some (.matchExpr scrutinee (arms.map fun arm => + { arm with body := tailReturns fallible arm.body.stmts })) } + | _ => { stmts } + +mutual + private partial def bareReturns (block : RustBlock) : RustBlock := + { block with stmts := block.stmts.map bareReturn } + private partial def bareReturn : RustStmt → RustStmt + | .returnStmt _ => .returnStmt unit + | .matchStmt scrutinee arms => + .matchStmt scrutinee (arms.map fun arm => { arm with body := bareReturns arm.body }) + | .letPattern pat ty (.labeledBlock label block) => + .letPattern pat ty (.labeledBlock label (bareReturns block)) + | .block stmts => .block (stmts.map bareReturn) + | stmt => stmt +end + +/-- The writer's source and whether it can fail. -/ +private def emitFunction (plan : FunctionPlan) (mode : Mode) : Except String (String × Bool) := do + let mut body := #[] + for i in [:plan.layout.inputSize] do + let value := if mode == .row then call "G::from_u64" #[indexExpr "seed" (1+i)] + else .index (.field (.var "context") "inputs") (.nat i) + body := body.push (declaration s!"v_{i}" value) + body := body ++ (← emitBlock plan mode plan.body none 0) + let rendered := stmtsToStr body + let fallible := rendered.contains '?' || (rendered.splitOn "Err(").length > 1 + let block := tailReturns fallible body + let block := if fallible then block else bareReturns block + let name := if mode == .row then s!"write_{plan.index}" + else s!"pack_{plan.index}" ++ (if mode == .typed then "_typed" else "") + let params : Array (String × RustType) := if mode == .row then + #[("seed", u64Slice false), ("offsets", .named "RowOffsets"), ("row", u64Slice true)] + else + #[("context", .ref false (.named "SeedContext<'_>")), + ("seed", if mode == .typed then .ref true (.named "TypedSeed<'_>") else u64Slice true)] + let returnTy : RustType := if fallible then .app "TraceResult" #[.tuple #[]] else .tuple #[] + pure ((RustItem.function { name, params, returnTy, body := block }).toStr, fallible) + +private def vector (xs : Array String) : String := "vec![" ++ ", ".intercalate xs.toList ++ "]" +private def indices (xs : Array Nat) : String := vector (xs.map toString) +private def app (name : String) (args : Array String) : String := name ++ "(" ++ ", ".intercalate args.toList ++ ")" +private def quoted (s : String) : String := (repr s).pretty +private def stringOption (s : Option String) : String := + (s.map fun s => s!"Some({quoted s}.into())").getD "None" + +private def bytecodeOp : Op → String + | .const v => app "Op::Const" #[s!"G::from_u64({v.n})"] + | .add a b => app "Op::Add" #[toString a, toString b] + | .sub a b => app "Op::Sub" #[toString a, toString b] + | .mul a b => app "Op::Mul" #[toString a, toString b] + | .eqZero a => app "Op::EqZero" #[toString a] + | .call f args size unc => app "Op::Call" #[toString f, indices args, toString size, toString unc] + | .store args => app "Op::Store" #[indices args] + | .load size a => app "Op::Load" #[toString size, toString a] + | .assertEq a b msg => app "Op::AssertEq" #[indices a, indices b, stringOption msg] + | .ioGetInfo c key => app "Op::IOGetInfo" #[toString c, indices key] + | .ioSetInfo c key i n => app "Op::IOSetInfo" #[toString c, indices key, toString i, toString n] + | .ioRead c i n => app "Op::IORead" #[toString c, toString i, toString n] + | .ioWrite c args => app "Op::IOWrite" #[toString c, indices args] + | .u8BitDecomposition a => app "Op::U8BitDecomposition" #[toString a] + | .u8ShiftLeft a => app "Op::U8ShiftLeft" #[toString a] + | .u8ShiftRight a => app "Op::U8ShiftRight" #[toString a] + | .u8Xor a b => app "Op::U8Xor" #[toString a, toString b] + | .u8Add a b => app "Op::U8Add" #[toString a, toString b] + | .u8Sub a b => app "Op::U8Sub" #[toString a, toString b] + | .u8Mul a b => app "Op::U8Mul" #[toString a, toString b] + | .u8And a b => app "Op::U8And" #[toString a, toString b] + | .u8Or a b => app "Op::U8Or" #[toString a, toString b] + | .u8LessThan a b => app "Op::U8LessThan" #[toString a, toString b] + | .u32LessThan a b => app "Op::U32LessThan" #[toString a, toString b] + | .u8XorSplit7 a b => app "Op::U8XorSplit7" #[toString a, toString b] + | .u8XorSplit4 a b => app "Op::U8XorSplit4" #[toString a, toString b] + | .debug msg args => app "Op::Debug" #[s!"{quoted msg}.into()", (args.map fun a => s!"Some({indices a})").getD "None"] + | .u8RangeCheck a b => app "Op::U8RangeCheck" #[toString a, toString b] + | .unconstrainedBigUintDivMod a b => app "Op::UnconstrainedBigUintDivMod" #[toString a, toString b] + | .unconstrainedGToBytes a => app "Op::UnconstrainedGToBytes" #[toString a] + | .unconstrainedGInverse a => app "Op::UnconstrainedGInverse" #[toString a] + | .unconstrainedU32Add a b => app "Op::UnconstrainedU32Add" #[indices a, indices b] + | .unconstrainedU32Add3 a b c => app "Op::UnconstrainedU32Add3" #[indices a, indices b, indices c] + | .u32ToField a => app "Op::U32ToField" #[indices a] + +mutual + private partial def bytecodeBlock (block : Bytecode.Block) : String := + "Block { ops: " ++ vector (block.ops.map bytecodeOp) ++ ", ctrl: " ++ bytecodeControl block.ctrl ++ " }" + private partial def bytecodeArms (arms : Array (G × Bytecode.Block)) : String := + "[" ++ ", ".intercalate (arms.toList.map fun (v, b) => + s!"(G::from_u64({v.n}), {bytecodeBlock b})") ++ "].into_iter().collect()" + private partial def bytecodeFallback (block : Option Bytecode.Block) : String := + (block.map fun block => s!"Some(Box::new({bytecodeBlock block}))").getD "None" + private partial def bytecodeControl : Ctrl → String + | .return s xs => app "Ctrl::Return" #[toString s, indices xs] + | .yield s xs => app "Ctrl::Yield" #[toString s, indices xs] + | .match d arms fallback => app "Ctrl::Match" #[toString d, bytecodeArms arms, bytecodeFallback fallback] + | .matchContinue d arms fallback n aux lookup continuation => app "Ctrl::MatchContinue" + #[toString d, bytecodeArms arms, bytecodeFallback fallback, toString n, toString aux, + toString lookup, s!"Box::new({bytecodeBlock continuation})"] +end + +private def layout (l : Bytecode.FunctionLayout) : String := + "FunctionLayout { " ++ s!"input_size: {l.inputSize}, selectors: {l.selectors}, auxiliaries: {l.auxiliaries}, lookups: {l.lookups}" ++ " }" + +private def expected (top : Bytecode.Toplevel) : String := + -- Keep bytecode constructors separate so LLVM does not optimize the entire + -- function library as one allocation-heavy function. + let definitions := top.functions.zipIdx.map fun (f, index) => + s!"#[inline(never)]\nfn expected_function_{index}() -> Function " ++ "{\n" ++ + " Function { body: " ++ bytecodeBlock f.body ++ ", layout: " ++ layout f.layout ++ + s!", entry: {f.entry}, constrained: {f.constrained}" ++ " }\n}\n" + let functions := (Array.range top.functions.size).map fun index => s!"expected_function_{index}()" + let circuits := top.circuits.map fun c => + "Circuit { members: " ++ indices c.members ++ ", layout: " ++ layout c.layout ++ " }" + "\n".intercalate definitions.toList ++ "\nfn expected_program() -> Toplevel {\n Toplevel { functions: " ++ vector functions ++ + ", memory_sizes: " ++ indices top.memorySizes ++ ", circuits: " ++ vector circuits ++ " }\n}\n" + +/-- Scalar and seed writers share the planned SSA values and fixed column spans. +The complete expected bytecode guards runtime binding, including partial coverage. -/ +def emit (top : Bytecode.Toplevel) (cratePath : String := "aiur") + (selected : Option (Array FunIdx) := none) : Except String String := do + let plan ← TracePlan.program top + if let some indices := selected then + for index in indices do + unless (plan.functions[index]?.join).isSome do + throw s!"function {index} is missing or unconstrained" + unless indices.toList.eraseDups.length == indices.size do + throw "duplicate selected function" + let mut source := "// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode.\n" ++ + "#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)]\n" ++ + s!"use {cratePath}::" ++ "{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl},\n" ++ + " execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*};\n" ++ + "use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64};\n\n" + let mut descriptors := #[] + for entry in plan.functions do + match entry with + | none => descriptors := descriptors.push "None" + | some f => + if !(selected.map (·.contains f.index)).getD true then + descriptors := descriptors.push "None" + continue + -- The registry holds fallible writers; an infallible one is wrapped + -- in a closure, which coerces to the function pointer. + let mut entries := #[] + for mode in #[Mode.pack, .typed, .row] do + let (text, fallible) ← emitFunction f mode + source := source ++ text ++ "\n" + let name := if mode == .row then s!"write_{f.index}" + else s!"pack_{f.index}" ++ (if mode == .typed then "_typed" else "") + let args := if mode == .row then "seed, offsets, row" else "context, seed" + entries := entries.push (if fallible then name + else s!"|{args}| " ++ "{ " ++ s!"{name}({args}); Ok(()) " ++ "}") + source := source ++ s!"static SCHEMA_{f.index}: SeedSchema = SeedSchema " ++ "{ widths: &[" ++ + ", ".intercalate (f.seedSchema.widths.toList.map widthLiteral) ++ "], offsets: &[" ++ + ", ".intercalate (f.seedSchema.offsets.toList.map toString) ++ s!"], bytes: {f.seedSchema.bytes} " ++ "};\n\n" + descriptors := descriptors.push ("Some(FunctionWriter { layout: " ++ layout f.layout ++ + s!", output_size: {f.outputSize.getD 0}, seed_words: {f.seedWords}, schema: &SCHEMA_{f.index}, " ++ + s!"pack: {entries[0]!}, pack_typed: {entries[1]!}, write: {entries[2]!}" ++ " })") + source := source ++ expected top + pure (source ++ "pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [" ++ TraceContract.fingerprintLiteral top ++ s!"], complete: {selected.isNone}, expected: expected_program, functions: &[\n" ++ + ",\n".intercalate descriptors.toList ++ "\n] };\n") + +end Aiur.TraceCodegen + +end diff --git a/Ix/Aiur/Stages/TraceContract.lean b/Ix/Aiur/Stages/TraceContract.lean new file mode 100644 index 000000000..6aba5f6f9 --- /dev/null +++ b/Ix/Aiur/Stages/TraceContract.lean @@ -0,0 +1,99 @@ +module + +public import Ix.Aiur.Stages.Bytecode +public import Blake3.Rust + +public section + +namespace Aiur.TraceContract +open Bytecode + +/-- The wire format uses explicit variant tags, little-endian u64 lengths and +indices, single-byte flags, and length-prefixed UTF-8 strings. Arm order is +preserved because it determines default-arm inverse columns. -/ +private abbrev Encode := StateM ByteArray +private def byte (n : Nat) : Encode Unit := modify (·.push n.toUInt8) +private def word (n : Nat) : Encode Unit := do + for i in [:8] do byte ((n >>> (8*i)) &&& 255) +private def array (write : α → Encode Unit) (xs : Array α) : Encode Unit := do + word xs.size + for x in xs do write x +private def optional (write : α → Encode Unit) (x : Option α) : Encode Unit := do + match x with + | none => byte 0 + | some x => byte 1; write x +private def text (s : String) : Encode Unit := do + let bytes := s.toUTF8 + word bytes.size + modify (· ++ bytes) +private def indices := array word +private def unary (tag a : Nat) : Encode Unit := byte tag *> word a +private def binary (tag a b : Nat) : Encode Unit := unary tag a *> word b + +private def operation : Op → Encode Unit + | .const x => unary 0 x.n + | .add a b => binary 1 a b + | .sub a b => binary 2 a b + | .mul a b => binary 3 a b + | .eqZero a => unary 4 a + | .call f args n u => do byte 5; word f; indices args; word n; byte (if u then 1 else 0) + | .store xs => byte 6 *> indices xs + | .load n p => binary 7 n p + | .assertEq a b msg => do byte 8; indices a; indices b; optional text msg + | .ioGetInfo c key => do unary 9 c; indices key + | .ioSetInfo c key i n => do unary 10 c; indices key; word i; word n + | .ioRead c i n => do binary 11 c i; word n + | .ioWrite c xs => unary 12 c *> indices xs + | .u8BitDecomposition a => unary 13 a + | .u8ShiftLeft a => unary 14 a + | .u8ShiftRight a => unary 15 a + | .u8Xor a b => binary 16 a b + | .u8Add a b => binary 17 a b + | .u8Mul a b => binary 18 a b + | .u8Sub a b => binary 19 a b + | .u8And a b => binary 20 a b + | .u8Or a b => binary 21 a b + | .u8LessThan a b => binary 22 a b + | .u32LessThan a b => binary 23 a b + | .u8XorSplit7 a b => binary 24 a b + | .u8XorSplit4 a b => binary 25 a b + | .debug msg args => do byte 26; text msg; optional indices args + | .u8RangeCheck a b => binary 27 a b + | .unconstrainedBigUintDivMod a b => binary 28 a b + | .unconstrainedGToBytes a => unary 29 a + | .unconstrainedGInverse a => unary 30 a + | .unconstrainedU32Add a b => do byte 31; indices a; indices b + | .unconstrainedU32Add3 a b c => do byte 32; indices a; indices b; indices c + | .u32ToField a => byte 33 *> indices a + +mutual + private partial def block (b : Block) : Encode Unit := array operation b.ops *> control b.ctrl + private partial def arms (xs : Array (G × Block)) : Encode Unit := + array (fun (value, body) => word value.n *> block body) xs + private partial def control : Ctrl → Encode Unit + | .match d xs fallback => do unary 0 d; arms xs; optional block fallback + | .return s xs => unary 1 s *> indices xs + | .yield s xs => unary 2 s *> indices xs + | .matchContinue d xs fallback n aux lookup continuation => do + unary 3 d; arms xs; optional block fallback + word n; word aux; word lookup; block continuation +end + +private def layout (l : FunctionLayout) : Encode Unit := do + word l.inputSize; word l.selectors; word l.auxiliaries; word l.lookups + +def bytes (top : Toplevel) : ByteArray := Id.run do + let write : Encode Unit := do + array (fun f => do + layout f.layout; byte (if f.entry then 1 else 0); byte (if f.constrained then 1 else 0) + block f.body) top.functions + indices top.memorySizes + return (write.run "aiur-trace-library-v1/seed-v2/writer-v2\x00".toUTF8).2 + +def fingerprint (top : Toplevel) : ByteArray := (Blake3.Rust.hash (bytes top)).val + +def fingerprintLiteral (top : Toplevel) : String := + ", ".intercalate ((fingerprint top).data.toList.map toString) + +end Aiur.TraceContract +end diff --git a/Ix/Aiur/Stages/TraceCuda.lean b/Ix/Aiur/Stages/TraceCuda.lean new file mode 100644 index 000000000..363f05a77 --- /dev/null +++ b/Ix/Aiur/Stages/TraceCuda.lean @@ -0,0 +1,289 @@ +module + +public import Ix.Aiur.Stages.TracePlan +public import Ix.Aiur.Stages.TraceContract + +public section + +namespace Aiur.TraceCuda + +open Bytecode TracePlan + +private def literal (n : Nat) : String := s!"{n}ULL" +private def valueName (id : ValueId) : String := s!"v_{id}" +private def call (name : String) (args : Array String) : String := + name ++ "(" ++ ", ".intercalate args.toList ++ ")" +private def line (depth : Nat) (text : String) : String := + String.ofList (List.replicate (2*depth) ' ') ++ text ++ "\n" +private def column (region : String) (index : Nat) (value : String) : String := + s!"row[layout.{region} + {index}] = {value};" + +private structure Emission where + counter : Nat := 0 + tables : Array String := #[] + +private abbrev EmitM := StateT Emission (Except String) + +private def fresh (stem : String) : EmitM String := do + let n := (← get).counter + modify fun state => { state with counter := n+1 } + pure s!"{stem}_{n}" + +private def emitOperation (operation : Operation) (depth : Nat) : Except String String := do + let args := operation.inputs.map valueName + let a := args[0]?.getD "0ULL" + let b := args[1]?.getD "0ULL" + let temp := s!"op_{operation.index}" + let mut source := "" + let mut auxiliary : Option (Array String) := none + let outputs ← match operation.externalRead with + | some read => pure ((Array.range read.seed.size).map fun i => s!"seed.word({read.seed.start+i})") + | none => + match operation.opcode with + | .const g => pure #[literal g.n] + | .add .. => pure #[call "goldilocks_add" #[a, b]] + | .sub .. => pure #[call "goldilocks_sub" #[a, b]] + | .mul .. => pure #[call "goldilocks_mul" #[a, b]] + | .eqZero .. => + if operation.auxiliaries.size != 0 then + auxiliary := some #[s!"inverse({a})", valueName operation.outputs[0]!] + pure #[s!"uint64_t({a} == 0)"] + | .unconstrainedGInverse .. => pure #[s!"inverse({a})"] + | .unconstrainedGToBytes .. => + pure ((Array.range 8).map fun i => s!"(({a} >> {8*i}) & 255ULL)") + | .u8BitDecomposition .. => + pure ((Array.range 8).map fun i => s!"(({a} >> {i}) & 1ULL)") + | .u8ShiftLeft .. => pure #[s!"(({a} << 1) & 255ULL)"] + | .u8ShiftRight .. => pure #[s!"({a} >> 1)"] + | .u8Xor .. | .u8Add .. | .u8Sub .. | .u8Mul .. | .u8And .. + | .u8Or .. | .u8LessThan .. | .u8XorSplit4 .. | .u8XorSplit7 .. => + source := source ++ line depth s!"if ({a} > 255 || {b} > 255) return 1;" + match operation.opcode with + | .u8Xor .. => pure #[s!"({a} ^ {b})"] + | .u8And .. => pure #[s!"({a} & {b})"] + | .u8Or .. => pure #[s!"({a} | {b})"] + | .u8LessThan .. => pure #[s!"uint64_t({a} < {b})"] + | .u8Add .. => pure #[s!"(({a} + {b}) & 255ULL)", s!"(({a} + {b}) >> 8)"] + | .u8Sub .. => pure #[s!"(({a} - {b}) & 255ULL)", s!"uint64_t({a} < {b})"] + | .u8Mul .. => pure #[s!"(({a} * {b}) & 255ULL)", s!"(({a} * {b}) >> 8)"] + | .u8XorSplit4 .. => pure #[s!"(({a} ^ {b}) >> 4)", s!"((({a} ^ {b}) << 4) & 255ULL)"] + | _ => pure #[s!"(({a} ^ {b}) >> 7)", s!"((({a} ^ {b}) << 1) & 255ULL)"] + | .u32LessThan .. => + source := source ++ line depth s!"if ({a} > 0xffffffffULL || {b} > 0xffffffffULL) return 3;" + source := source ++ line depth s!"const uint32_t {temp} = uint32_t({a}) - uint32_t({b});" + -- Six u16 limbs ordered as a, a - b, b, low limb first: the host + -- witness's scalar range-check queries. + auxiliary := some ((#[a, s!"uint64_t({temp})", b]).flatMap fun word => + #[s!"({word} & 0xffffULL)", s!"(({word} >> 16) & 0xffffULL)"]) + pure #[s!"uint64_t({a} < {b})"] + | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. => + let words := (Array.range (args.size / 4)).map fun i => call "word" (args.extract (4*i) (4*i+4)) + source := source ++ line depth s!"const WordSum {temp} = {call "add_words" words};" + pure (((Array.range 4).map fun i => s!"(({temp}.low >> {8*i}) & 255ULL)").push s!"{temp}.carry") + | .u32ToField .. => pure #[call "canonicalize" #[call "word" args]] + | .assertEq .. | .ioSetInfo .. | .ioWrite .. | .debug .. | .u8RangeCheck .. => pure #[] + | .call .. | .load .. | .ioRead .. => + if operation.outputs.isEmpty then pure #[] else throw "missing CUDA external read" + | .store .. | .ioGetInfo .. | .unconstrainedBigUintDivMod .. => throw "missing CUDA external read" + unless outputs.size == operation.outputs.size do throw "CUDA logical output count differs from plan" + for i in [:outputs.size] do + source := source ++ line depth s!"const uint64_t {valueName operation.outputs[i]!} = {outputs[i]!};" + let columns := auxiliary.getD ((operation.outputs.extract 0 operation.auxiliaries.size).map valueName) + unless columns.size == operation.auxiliaries.size do throw "CUDA auxiliary count differs from plan" + for i in [:columns.size] do + source := source ++ line depth (column "auxiliaries" (operation.auxiliaries.start+i) columns[i]!) + pure source + +private structure YieldTarget where + label : String + merges : Array ValueId + +mutual + private partial def emitBlock (plan : FunctionPlan) (block : BlockPlan) + (target : Option YieldTarget) (depth : Nat) : EmitM String := do + let mut source := "" + for index in block.operations do + if plan.rowOperations.contains index then + let some operation := plan.operations[index]? | throw "missing CUDA operation" + source := source ++ (← emitOperation operation depth) + pure (source ++ (← emitControl plan block.control target depth)) + + private partial def emitArms (plan : FunctionPlan) (discriminant : ValueId) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (inverses : Span) + (target : Option YieldTarget) (depth : Nat) : EmitM String := do + let d := valueName discriminant + let mut source := line depth (s!"switch ({d}) " ++ "{") + for (value, block) in arms do + source := source ++ line (depth+1) (s!"case {literal value.n}: " ++ "{") + source := source ++ (← emitBlock plan block target (depth+2)) + source := source ++ line (depth+1) "}" + source := source ++ line (depth+1) "default: {" + match fallback with + | none => source := source ++ line (depth+2) "return 2;" + | some block => + let maximum := arms.foldl (fun maximum (g, _) => max maximum g.n) 0 + for ((value, _), i) in arms.zipIdx do + let generic := s!"inverse(goldilocks_sub({d}, {literal value.n}))" + let expression ← if maximum < 16 then do + let table ← fresh s!"inverse_{plan.index}" + let items := (Array.range (maximum+1)).map fun n => literal ((G.ofNat n - value).inverse.n) + let declaration := s!"__device__ __constant__ uint64_t {table}[] = " ++ + "{" ++ ", ".intercalate items.toList ++ "};\n" + modify fun state => { state with tables := state.tables.push declaration } + pure s!"({d} <= {literal maximum} ? {table}[{d}] : {generic})" + else pure generic + source := source ++ line (depth+2) (column "auxiliaries" (inverses.start+i) expression) + source := source ++ (← emitBlock plan block target (depth+2)) + pure (source ++ line (depth+1) "}" ++ line depth "}") + + private partial def emitControl (plan : FunctionPlan) (control : Control) + (target : Option YieldTarget) (depth : Nat) : EmitM String := do + match control with + | .returnRow selector _ => + pure (line depth (column "selectors" selector "1") ++ line depth "return 0;") + | .yieldRow selector values => + let some target := target | throw "CUDA yield has no continuation" + let mut source := line depth (column "selectors" selector "1") + for i in [:values.size] do + source := source ++ line depth s!"{valueName target.merges[i]!} = {valueName values[i]!};" + pure (source ++ line depth s!"goto {target.label};") + | .branch discriminant arms fallback inverses _ => + emitArms plan discriminant arms fallback inverses target depth + | .continueWith discriminant arms fallback inverses _ merges columns continuation => + let label ← fresh "continuation" + let mut source := "" + for id in merges do source := source ++ line depth s!"uint64_t {valueName id};" + source := source ++ (← emitArms plan discriminant arms fallback inverses (some ⟨label, merges⟩) depth) + source := source ++ line depth s!"{label}:;" + for i in [:merges.size] do + source := source ++ line depth (column "auxiliaries" (columns.start+i) (valueName merges[i]!)) + pure (source ++ (← emitBlock plan continuation target depth)) +end + +private def loader : SeedWidth → String + | .u8 => "load_u8" | .u16 => "load_u16" | .u32 => "load_u32" | .full => "load_u64" + +private def emitFunction (plan : FunctionPlan) (unit : String) : Except String String := do + let name := s!"{unit}_{plan.index}" + let schema := plan.seedSchema + let (body, state) ← (emitBlock plan plan.body none 1).run {} + let mut source := "".intercalate state.tables.toList + -- Call sites pass literal indices, so the switch folds to one typed load. + source := source ++ s!"template struct Seed_{name} " ++ "{\n const uint8_t* data;\n" ++ + " __device__ __forceinline__ uint64_t word(size_t index) const {\n" ++ + " if constexpr (!Typed) return reinterpret_cast(data)[index];\n" ++ + " switch (index) {\n" + for i in [:schema.widths.size] do + source := source ++ s!" case {i}: return {loader schema.widths[i]!}(data + {schema.offsets[i]!});\n" + source := source ++ " default: return 0;\n }\n }\n};\n" + source := source ++ s!"template __device__ __forceinline__ uint32_t row_{name}(Seed_{name} seed, Layout layout, uint64_t* row) " ++ "{\n" + for i in [:plan.layout.inputSize] do + source := source ++ line 1 s!"const uint64_t v_{i} = seed.word({i+1});" + source := source ++ line 1 s!"row[{i}] = v_{i};" + source := source ++ body ++ "}\n" + source := source ++ s!"template __global__ void kernel_{name}(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) " ++ "{\n" ++ + " const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x;\n" ++ + " if (r >= real) return;\n" ++ + " uint64_t* row = output + r * layout.width;\n" ++ + s!" constexpr size_t stride = Typed ? {plan.typedSeedBytes} : {plan.canonicalSeedBytes};\n" ++ + s!" const Seed_{name} seed" ++ "{seeds + r * stride};\n" ++ + " row[layout.auxiliaries] = seed.word(0);\n" ++ + s!" const uint32_t status = row_{name}(seed, layout, row);\n" ++ + " if (status) atomicCAS(error, 0U, status);\n}\n" + source := source ++ s!"cudaError_t launch_{name}(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) " ++ "{\n" ++ + s!" if (encoding == 1) kernel_{name}<<>>(seeds, real, rows, layout, output, error);\n" ++ + s!" else kernel_{name}<<>>(seeds, real, rows, layout, output, error);\n" ++ + " return cudaGetLastError();\n}\n" + source := source ++ s!"extern \"C\" int aiur_trace_{name}(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) " ++ "{\n" ++ + s!" if (selectors < {plan.layout.inputSize} || auxiliaries < selectors || auxiliaries - selectors < {plan.layout.selectors} || width < auxiliaries || width - auxiliaries < {plan.layout.auxiliaries}) return int(cudaErrorInvalidValue);\n" ++ + s!" const size_t stride = encoding == 1 ? {plan.typedSeedBytes} : encoding == 0 ? {plan.canonicalSeedBytes} : 0;\n" ++ + " return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, " ++ s!"output, launch_{name});\n" ++ "}\n\n" + pure source + +/-- Byte encoding of the selected functions' seed schemas, hashed into the +compiled unit's schema contract. The runtime recomputes it from the Rust +writers' schemas at bind, so a CUDA unit and a seed packer generated from +different compiler revisions cannot agree by total size alone. Little-endian +u64 fields; widths as their byte counts. -/ +private def schemaContract (plan : ProgramPlan) (selected : Option (Array FunIdx)) : ByteArray := Id.run do + let word := fun (bytes : ByteArray) (n : Nat) => Id.run do + let mut bytes := bytes + for i in [:8] do bytes := bytes.push ((n >>> (8*i)) &&& 255).toUInt8 + return bytes + let mut bytes := "aiur-trace-schema-v1\x00".toUTF8 + for entry in plan.functions do + if let some f := entry then + if (selected.map (·.contains f.index)).getD true then + bytes := word bytes f.index + bytes := word bytes f.seedWords + bytes := word bytes f.seedSchema.bytes + for width in f.seedSchema.widths do bytes := bytes.push width.bytes.toUInt8 + for offset in f.seedSchema.offsets do bytes := word bytes offset + return bytes + +private def schemaContractLiteral (plan : ProgramPlan) (selected : Option (Array FunIdx)) : String := + ", ".intercalate ((Blake3.Rust.hash (schemaContract plan selected)).val.data.toList.map toString) + +def validUnit (unit : String) : Bool := + !unit.isEmpty && unit.toList.all (fun c => c.isAlphanum && c.toNat < 128 || c == '_') && + !(unit.toList.head!).isDigit + +def emit (top : Toplevel) (unit : String) (selected : Option (Array FunIdx) := none) : Except String String := do + unless validUnit unit do throw "CUDA unit must be an ASCII identifier" + let plan ← TracePlan.program top + if let some indices := selected then + let mut seen := #[] + for index in indices do + unless (plan.functions[index]?).join.isSome do + throw s!"function {index} has no constrained trace writer" + if seen.contains index then throw s!"duplicate CUDA function {index}" + seen := seen.push index + let mut source := "// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode.\n" ++ + "#include \"trace_primitives.cuh\"\nstatic_assert(aiur_trace::ABI_VERSION == 2, \"trace writer ABI mismatch\");\n" ++ s!"namespace trace_{unit} " ++ "{\nusing namespace aiur_trace;\n\n" + for entry in plan.functions do + if let some function := entry then + if (selected.map (·.contains function.index)).getD true then + source := source ++ (← emitFunction function unit) + pure (source ++ s!"extern \"C\" const uint8_t* aiur_trace_{unit}_contract() " ++ "{\n" ++ + " static const uint8_t hash[32] = {" ++ TraceContract.fingerprintLiteral top ++ "};\n return hash;\n}\n" ++ + s!"extern \"C\" const uint8_t* aiur_trace_{unit}_schema() " ++ "{\n" ++ + " static const uint8_t hash[32] = {" ++ schemaContractLiteral plan selected ++ "};\n return hash;\n}\n}\n") + +/-- Rust registration for the CUDA unit; absent entries remain explicit. -/ +def registry (top : Toplevel) (unit : String) (cratePath : String := "aiur") + (selected : Option (Array FunIdx) := none) : Except String String := do + unless validUnit unit do throw "CUDA unit must be an ASCII identifier" + let plan ← TracePlan.program top + if let some indices := selected then + let mut seen := #[] + for index in indices do + unless (plan.functions[index]?).join.isSome do + throw s!"function {index} has no constrained trace writer" + if seen.contains index then throw s!"duplicate CUDA function {index}" + seen := seen.push index + let mut source := "// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode.\n" ++ + s!"use {cratePath}::trace_codegen::cuda::CudaLibrary;\nunsafe extern \"C\" " ++ "{\n" ++ + s!" fn aiur_trace_{unit}_contract() -> *const u8;\n" ++ + s!" fn aiur_trace_{unit}_schema() -> *const u8;\n" + let mut entries := #[] + let mut words := #[] + let mut typed := #[] + for entry in plan.functions do + words := words.push (toString ((entry.map (·.seedWords)).getD 0)) + typed := typed.push (toString ((entry.map (·.typedSeedBytes)).getD 0)) + match entry with + | some f => + if (selected.map (·.contains f.index)).getD true then + let name := s!"aiur_trace_{unit}_{f.index}" + source := source ++ s!" pub(super) fn {name}(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32;\n" + entries := entries.push s!"Some({name})" + else entries := entries.push "None" + | none => entries := entries.push "None" + pure (source ++ "}\n" ++ + "pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([" ++ TraceContract.fingerprintLiteral top ++ + s!"], aiur_trace_{unit}_contract, aiur_trace_{unit}_schema, &[\n" ++ ",\n".intercalate entries.toList ++ "\n], &[" ++ ", ".intercalate words.toList ++ + "], &[" ++ ", ".intercalate typed.toList ++ "]) };\n") + +end Aiur.TraceCuda + +end diff --git a/Ix/Aiur/Stages/TracePlan.lean b/Ix/Aiur/Stages/TracePlan.lean new file mode 100644 index 000000000..3fde01b23 --- /dev/null +++ b/Ix/Aiur/Stages/TracePlan.lean @@ -0,0 +1,849 @@ +module + +public import Ix.Aiur.Compiler.Layout + +/-! +Main-trace planning over final Aiur bytecode. Column spans are relative to +their input, selector, auxiliary or lookup region, so a function plan can be +instantiated inside a grouped circuit. Value IDs are unique across branches; +bytecode's branch-local indices are resolved while building the plan. +-/ + +public section + +namespace Aiur.TracePlan + +open Bytecode + +abbrev ValueId := Nat + +structure Span where + start : Nat + size : Nat + deriving Inhabited, Repr, BEq + +structure BranchSpace where + auxiliaries : Span + lookups : Span + seeds : Span + deriving Inhabited, Repr + +structure Value where + degree : Nat + producer : Option Nat := none + input : Option Nat := none + rowInputs : Array ValueId := #[] + preparationInputs : Array ValueId := #[] + deriving Inhabited, Repr + +inductive ReadKind where + | callResult (callee : FunIdx) + | returnedCall (callee : FunIdx) + | storePointer (width : Nat) + | loadValues (width : Nat) + | ioInfo + | ioValues (length : Nat) + | bigUintResults + deriving Inhabited, Repr, BEq + +structure ExternalRead where + kind : ReadKind + inputs : Array ValueId + seed : Span + deriving Inhabited, Repr + +structure Operation where + index : Nat + opcode : Op + inputs : Array ValueId + outputs : Array ValueId + outputDegrees : Array Nat + auxiliaries : Span + lookups : Span + externalRead : Option ExternalRead + deriving Repr + +mutual + inductive Control where + | returnRow (selector : SelIdx) (values : Array ValueId) + | yieldRow (selector : SelIdx) (values : Array ValueId) + | branch (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (defaultWitnesses : Span) (space : BranchSpace) + | continueWith (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (defaultWitnesses : Span) (space : BranchSpace) + (mergeValues : Array ValueId) (mergeColumns : Span) (continuation : BlockPlan) + deriving Inhabited, Repr + + structure BlockPlan where + operations : Array Nat + control : Control + deriving Inhabited, Repr +end + +/-- Storage for one seed word in the typed encoding. The multiplicity word is +always full width: negative field values are ordinary multiplicities. -/ +inductive SeedWidth where + | u8 | u16 | u32 | full + deriving Inhabited, Repr, BEq, DecidableEq + +def SeedWidth.bytes : SeedWidth → Nat + | .u8 => 1 | .u16 => 2 | .u32 => 4 | .full => 8 + +/-- The narrowest width holding every canonical value below `bound`. -/ +def SeedWidth.ofBound (bound : Nat) : SeedWidth := + if bound ≤ 256 then .u8 else if bound ≤ 65536 then .u16 + else if bound ≤ 4294967296 then .u32 else .full + +/-- Byte layout of one typed seed. Words are stored widest first, in index +order within a width, so every word is naturally aligned and the multiplicity +stays at offset zero; the stride is padded to a multiple of eight. -/ +structure SeedSchema where + widths : Array SeedWidth + offsets : Array Nat + bytes : Nat + deriving Inhabited, Repr, BEq + +def SeedSchema.ofWidths (widths : Array SeedWidth) : SeedSchema := Id.run do + let mut offsets := Array.replicate widths.size 0 + let mut cursor := 0 + for width in #[SeedWidth.full, .u32, .u16, .u8] do + for i in [:widths.size] do + if widths[i]! == width then + offsets := offsets.set! i cursor + cursor := cursor + width.bytes + return { widths, offsets, bytes := ((cursor + 7) / 8) * 8 } + +def SeedSchema.canonical (words : Nat) : SeedSchema := + SeedSchema.ofWidths (Array.replicate words .full) + +/-- A schema whose typed and canonical encodings coincide. -/ +def SeedSchema.isCanonical (schema : SeedSchema) : Bool := + schema.widths.all (· == .full) + +structure FunctionPlan where + index : FunIdx + layout : FunctionLayout + outputSize : Option Nat + body : BlockPlan + values : Array Value + operations : Array Operation + /-- Full-width seed words: multiplicity, inputs, then branch-shared reads. -/ + seedWords : Nat + /-- Speculative per-word widths; the packer guards every narrowed word. -/ + seedSchema : SeedSchema + rowOperations : Array Nat + preparationOperations : Array Nat + rowValues : Array ValueId + preparationValues : Array ValueId + deriving Repr + +def FunctionPlan.canonicalSeedBytes (plan : FunctionPlan) : Nat := + 8 * plan.seedWords + +def FunctionPlan.typedSeedBytes (plan : FunctionPlan) : Nat := + plan.seedSchema.bytes + +structure ProgramPlan where + /-- Indexed by function ID; unconstrained functions have no row writer. -/ + functions : Array (Option FunctionPlan) + circuits : Array Circuit + deriving Repr + +/-- The functions of every circuit whose members together pack into at most +half their canonical seeds. A circuit is generated only when every member +is, so the selection is by circuit and the ratio is summed over its members; +it is the static signal that a seed is cheaper to move than the row it +replaces. Row weights, when they exist, should refine this. -/ +def ProgramPlan.compactCircuitFunctions (plan : ProgramPlan) : Array FunIdx := Id.run do + let mut selected := #[] + for circuit in plan.circuits do + let sizes := circuit.members.filterMap fun member => + plan.functions[member]?.join.map fun f => (f.typedSeedBytes, f.canonicalSeedBytes) + let typed := sizes.foldl (fun n (t, _) => n + t) 0 + let canonical := sizes.foldl (fun n (_, c) => n + c) 0 + if sizes.size == circuit.members.size && 2 * typed ≤ canonical then + selected := selected ++ circuit.members + return selected + +private structure Scope where + locals : Array ValueId := #[] + degrees : Array Nat := #[] + auxiliary : Nat := 1 + lookup : Nat := 1 + seed : Nat := 1 + deriving Inhabited + +private def Scope.maxSpace (base other : Scope) : Scope := + { base with + auxiliary := max base.auxiliary other.auxiliary + lookup := max base.lookup other.lookup + seed := max base.seed other.seed } + +private def Scope.spaceTo (start finish : Scope) : BranchSpace := + { auxiliaries := ⟨start.auxiliary, finish.auxiliary - start.auxiliary⟩ + lookups := ⟨start.lookup, finish.lookup - start.lookup⟩ + seeds := ⟨start.seed, finish.seed - start.seed⟩ } + +private structure BuildState where + values : Array Value := #[] + operations : Array Operation := #[] + selectors : Array SelIdx := #[] + outputSize : Option Nat := none + rowRoots : Array ValueId := #[] + rowWrites : Array Nat := #[] + preparationRoots : Array ValueId := #[] + +private abbrev PlanM := StateT BuildState (Except String) + +private structure BlockResult where + plan : BlockPlan + scope : Scope + /-- Yields escaping this block to its enclosing continuation. -/ + yields : Array (Array ValueId) := #[] + deriving Inhabited + +private def resolveLocal (scope : Scope) (index : ValIdx) : PlanM ValueId := + match scope.locals[index]? with + | some value => pure value + | none => throw s!"value {index} is outside the local stack of size {scope.locals.size}" + +private def resolveLocals (scope : Scope) (indices : Array ValIdx) : PlanM (Array ValueId) := + indices.mapM (resolveLocal scope) + +private def newValue (value : Value) : PlanM ValueId := do + let index := (← get).values.size + modify fun state => { state with values := state.values.push value } + pure index + +private def select (layout : FunctionLayout) (selector : SelIdx) : PlanM Unit := do + if selector >= layout.selectors then + throw s!"selector {selector} is outside the declared selector region" + if (← get).selectors.contains selector then + throw s!"selector {selector} is allocated by more than one terminal" + modify fun state => { state with selectors := state.selectors.push selector } + +private partial def returnsHaveSize (block : Bytecode.Block) (size : Nat) : Bool := + match block.ctrl with + | .return _ values => values.size == size + | .yield .. => true + | .match _ arms fallback => + arms.all (fun (_, arm) => returnsHaveSize arm size) && + (fallback.map (fun arm => returnsHaveSize arm size)).getD true + | .matchContinue _ arms fallback _ _ _ continuation => + arms.all (fun (_, arm) => returnsHaveSize arm size) && + (fallback.map (fun arm => returnsHaveSize arm size)).getD true && + returnsHaveSize continuation size + +private def checkWord (values : Array ValIdx) : PlanM Unit := do + unless values.size == 4 do + throw s!"u32 operand has {values.size} bytes instead of 4" + +private def checkMemory (top : Toplevel) (width : Nat) : PlanM Unit := do + unless top.memorySizes.contains width do + throw s!"memory width {width} has no table" + +private def checkOp (top : Toplevel) (op : Op) : PlanM Unit := do + match op with + | .call index inputs outputs unconstrained => + let some callee := top.functions[index]? + | throw s!"call target {index} does not exist" + unless unconstrained || callee.constrained do + throw s!"constrained call targets unconstrained function {index}" + unless inputs.size == callee.layout.inputSize do + throw s!"call {index}: input arity differs from its callee" + unless returnsHaveSize callee.body outputs do + throw s!"call {index}: output arity differs from its callee" + | .store values => checkMemory top values.size + | .load width _ => checkMemory top width + | .assertEq xs ys _ => + unless xs.size == ys.size do + throw "assertion operands have different arities" + | .unconstrainedU32Add xs ys => checkWord xs; checkWord ys + | .unconstrainedU32Add3 xs ys zs => checkWord xs; checkWord ys; checkWord zs + | .u32ToField xs => checkWord xs + | _ => pure () + +private def readKind (op : Op) (returned : Bool) : Option ReadKind := + match op with + | .call callee _ size _ => + if size == 0 then none + else some (if returned then .returnedCall callee else .callResult callee) + | .store values => some (.storePointer values.size) + | .load size _ => if size == 0 then none else some (.loadValues size) + | .ioGetInfo .. => some .ioInfo + | .ioRead _ _ size => if size == 0 then none else some (.ioValues size) + | .unconstrainedBigUintDivMod .. => some .bigUintResults + | _ => none + +private def isReturnedCall (op : Op) (base : Nat) (control : Ctrl) : Bool := + match op, control with + | .call _ _ size _, .return _ values => + size != 0 && values == Array.range' base size + | _, _ => false + +private def planOp (top : Toplevel) (scope : Scope) (op : Op) (control : Ctrl) : + PlanM (Nat × Scope) := do + let index := (← get).operations.size + checkOp top op + let inputs ← resolveLocals scope op.inputs + let initial : Concrete.Bytecode.LayoutMState := + { functionLayout := + { inputSize := 0, selectors := 0, + auxiliaries := scope.auxiliary, lookups := scope.lookup } + memSizes := .empty, degrees := scope.degrees } + let (_, allocated) := (Concrete.Bytecode.opLayout op).run initial + unless allocated.degrees.size == scope.degrees.size + op.outputCount do + throw s!"operation {index}: value count differs from layout degree count" + let auxiliaries : Span := + ⟨scope.auxiliary, allocated.functionLayout.auxiliaries - scope.auxiliary⟩ + let lookups : Span := + ⟨scope.lookup, allocated.functionLayout.lookups - scope.lookup⟩ + let returned := isReturnedCall op scope.locals.size control + let externalRead := (readKind op returned).map fun kind => + { kind, inputs := if returned then #[] else inputs, + seed := ⟨scope.seed, op.outputCount⟩ : ExternalRead } + let rowInputs := if externalRead.isSome then #[] else inputs + let preparationInputs := if returned then #[] else inputs + let outputDegrees := allocated.degrees.extract scope.degrees.size allocated.degrees.size + let outputs ← outputDegrees.mapM fun degree => + newValue { degree, producer := some index, rowInputs, preparationInputs } + let operation : Operation := + { index, opcode := op, inputs, outputs, outputDegrees, + auxiliaries, lookups, externalRead } + modify fun state => { state with operations := state.operations.push operation } + if auxiliaries.size != 0 then + modify fun state => { state with + rowWrites := state.rowWrites.push index + rowRoots := state.rowRoots ++ rowInputs } + if let some read := externalRead then + modify fun state => { state with preparationRoots := state.preparationRoots ++ read.inputs } + pure (index, { scope with + locals := scope.locals ++ outputs + degrees := allocated.degrees + auxiliary := allocated.functionLayout.auxiliaries + lookup := allocated.functionLayout.lookups + seed := scope.seed + (externalRead.map (·.seed.size)).getD 0 }) + +private def markRowBranch (discriminant : ValueId) : PlanM Unit := + modify fun state => { state with + rowRoots := state.rowRoots.push discriminant } + +mutual + private partial def planBlock (top : Toplevel) (layout : FunctionLayout) + (scope : Scope) (yieldSize : Option Nat) (block : Bytecode.Block) : + PlanM BlockResult := do + let mut scope := scope + let mut operations := #[] + for op in block.ops do + let (index, next) ← planOp top scope op block.ctrl + operations := operations.push index + scope := next + let result ← planControl top layout scope yieldSize block.ctrl + pure { result with plan := { result.plan with operations } } + + private partial def planArms (top : Toplevel) (layout : FunctionLayout) + (scope : Scope) (yieldSize : Option Nat) (arms : Array (G × Bytecode.Block)) + (fallback : Option Bytecode.Block) : + PlanM (Array (G × BlockPlan) × Option BlockPlan × Scope × Array (Array ValueId)) := do + let mut cases : Array G := #[] + let mut plans := #[] + let mut maximum := scope + let mut yields := #[] + for (value, block) in arms do + if cases.contains value then throw s!"duplicate match case {value.n}" + cases := cases.push value + let result ← planBlock top layout scope yieldSize block + plans := plans.push (value, result.plan) + maximum := maximum.maxSpace result.scope + yields := yields ++ result.yields + let mut fallbackPlan := none + if let some block := fallback then + let result ← planBlock top layout + { scope with auxiliary := scope.auxiliary + arms.size } yieldSize block + maximum := maximum.maxSpace result.scope + yields := yields ++ result.yields + fallbackPlan := some result.plan + pure (plans, fallbackPlan, maximum, yields) + + private partial def planControl (top : Toplevel) (layout : FunctionLayout) + (scope : Scope) (yieldSize : Option Nat) (control : Ctrl) : PlanM BlockResult := do + match control with + | .return selector indices => + let values ← resolveLocals scope indices + select layout selector + if let some size := (← get).outputSize then + unless values.size == size do throw "function returns have different arities" + modify fun state => { state with outputSize := some values.size } + pure { plan := ⟨#[], .returnRow selector values⟩, scope } + | .yield selector indices => + let values ← resolveLocals scope indices + unless yieldSize == some values.size do + throw "yield arity differs from its enclosing continuation" + select layout selector + modify fun state => { state with rowRoots := state.rowRoots ++ values } + pure { plan := ⟨#[], .yieldRow selector values⟩, scope, yields := #[values] } + | .match index arms fallback => + let discriminant ← resolveLocal scope index + let defaultWitnesses : Span := + ⟨scope.auxiliary, if fallback.isSome then arms.size else 0⟩ + let (arms, fallback, maximum, yields) ← planArms top layout scope yieldSize arms fallback + markRowBranch discriminant + pure { plan := ⟨#[], .branch discriminant arms fallback defaultWitnesses + (scope.spaceTo maximum)⟩, scope := maximum, yields } + | .matchContinue index arms fallback size sharedAux sharedLookups continuation => + let discriminant ← resolveLocal scope index + let defaultWitnesses : Span := + ⟨scope.auxiliary, if fallback.isSome then arms.size else 0⟩ + let (arms, fallback, maximum, yields) ← planArms top layout scope (some size) arms fallback + let space := scope.spaceTo maximum + unless space.auxiliaries.size == sharedAux && space.lookups.size == sharedLookups do + throw s!"continuation reserves aux/lookups {sharedAux}/{sharedLookups}, \ + but its branches need {space.auxiliaries.size}/{space.lookups.size}" + let mut merges := #[] + for i in [:size] do + let dependencies := yields.foldl (fun deps values => deps.push values[i]!) #[discriminant] + let value ← newValue { + degree := 1, rowInputs := dependencies, preparationInputs := dependencies } + merges := merges.push value + let next : Scope := { maximum with + locals := scope.locals ++ merges + degrees := scope.degrees ++ Array.replicate size 1 + auxiliary := maximum.auxiliary + size } + let result ← planBlock top layout next yieldSize continuation + markRowBranch discriminant + pure { result with plan := ⟨#[], .continueWith discriminant arms fallback + defaultWitnesses space merges ⟨maximum.auxiliary, size⟩ result.plan⟩ } + +end + +mutual + private partial def preparationControls (operations : Array Operation) + (block : BlockPlan) (afterYield : Bool) : Array ValueId × Bool := + let reads := block.operations.any fun index => + (operations[index]?.bind (·.externalRead)).isSome + let (roots, needed) := preparationControl operations block.control afterYield + (roots, reads || needed) + + private partial def preparationControl (operations : Array Operation) + (control : Control) (afterYield : Bool) : Array ValueId × Bool := + match control with + | .returnRow .. => (#[], false) + | .yieldRow .. => (#[], afterYield) + | .branch discriminant arms fallback _ _ => + preparationArms operations discriminant arms fallback afterYield + | .continueWith discriminant arms fallback _ _ _ _ continuation => + let (continuationRoots, continuationNeeded) := + preparationControls operations continuation afterYield + let (branchRoots, branchNeeded) := + preparationArms operations discriminant arms fallback continuationNeeded + (branchRoots ++ continuationRoots, branchNeeded || continuationNeeded) + + private partial def preparationArms (operations : Array Operation) (discriminant : ValueId) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) + (afterYield : Bool) : Array ValueId × Bool := Id.run do + let mut roots := #[] + -- Nested returns can bypass a read in an enclosing continuation. + -- Propagate that continuation demand through every intervening branch. + let mut needed := afterYield + for (_, block) in arms do + let (branchRoots, branchNeeded) := preparationControls operations block afterYield + roots := roots ++ branchRoots + needed := needed || branchNeeded + if let some block := fallback then + let (branchRoots, branchNeeded) := preparationControls operations block afterYield + roots := roots ++ branchRoots + needed := needed || branchNeeded + return (if needed then roots.push discriminant else roots, needed) +end + +private def dependencies (values : Array Value) (operationCount : Nat) + (roots : Array ValueId) (writes : Array Nat) (preparation : Bool) : + Array Nat × Array ValueId := Id.run do + let mut needed := Array.replicate values.size false + let mut operations := Array.replicate operationCount false + for root in roots do needed := needed.set! root true + for write in writes do operations := operations.set! write true + -- Dependencies precede their value, including continuation merges, whose + -- alternatives have already been assigned distinct IDs. + for offset in [:values.size] do + let index := values.size - 1 - offset + if needed[index]! then + let value := values[index]! + if let some producer := value.producer then + operations := operations.set! producer true + let inputs := if preparation then value.preparationInputs else value.rowInputs + for input in inputs do needed := needed.set! input true + return ((Array.range operationCount).filter fun index => operations[index]!, + (Array.range values.size).filter fun index => needed[index]!) + +/-! ## Seed value bounds + +Exclusive upper bounds on canonical values, `gSize` when unknown. A word is +narrowed when any use anywhere in the function constrains it: byte-table +operations, u32 comparisons, equality assertions, exhaustive matches, +arguments passed to constrained callees whose own inputs are narrow, and +pointer positions. Values produced by byte operations, constants, bounded +arithmetic, calls and memory loads carry their bounds forward, through +continuation merges, function outputs and memory tables. + +The union over paths is speculative on purpose: a value used as a byte on one +path is a byte on every path in the typed source language, and the packer +guards each narrowed word, so a wrong speculation costs a full-width span, +never a wrong row. Pointers are the other speculation: a memory pointer is +its record's base plus a table index and an I/O index counts buffer entries, +so both are taken to fit 32 bits. -/ + +private def unbounded : Nat := gSize.toNat + +/-- Memory pointers and I/O indices. -/ +private def pointerBound : Nat := 4294967296 + +/-- Bounds visible across the library: a function's inputs from their uses +inside it, its outputs from their producers at every return. -/ +structure FunctionBounds where + inputs : Array Nat + outputs : Array Nat + deriving Inhabited, Repr, BEq + +/-- What one function's analysis may assume about the rest of the library: +callee bounds, and per memory width the bound of each stored value over +every store site. A table with no store site is unknown. -/ +structure Library where + callee : FunIdx → Option FunctionBounds + memory : Nat → Option (Array Nat) + +def Library.empty : Library := { callee := fun _ => none, memory := fun _ => none } + +private def saturate (n : Nat) : Nat := min n unbounded + +private def producedBounds (lib : Library) (op : Operation) (bound : ValueId → Nat) : Array Nat := + let a := (op.inputs[0]?.map bound).getD unbounded + let b := (op.inputs[1]?.map bound).getD unbounded + let unknown := Array.replicate op.outputs.size unbounded + let bounds := match op.opcode with + | .const g => #[g.n + 1] + | .add .. => #[saturate (a + b - 1)] + | .mul .. => #[saturate ((a - 1) * (b - 1) + 1)] + | .eqZero .. | .u8LessThan .. | .u32LessThan .. => #[2] + | .u8BitDecomposition .. => Array.replicate 8 2 + | .unconstrainedGToBytes .. => Array.replicate 8 256 + | .u8ShiftLeft .. | .u8ShiftRight .. | .u8Xor .. | .u8And .. | .u8Or .. => #[256] + | .u8Add .. | .u8Sub .. => #[256, 2] + | .u8Mul .. => #[256, 256] + | .u8XorSplit4 .. => #[16, 256] + | .u8XorSplit7 .. => #[2, 256] + | .unconstrainedU32Add .. => #[256, 256, 256, 256, 2] + | .unconstrainedU32Add3 .. => #[256, 256, 256, 256, 3] + | .u32ToField .. => #[pointerBound] + | .call index _ _ false => ((lib.callee index).map (·.outputs)).getD unknown + | .store .. => #[pointerBound] + | .load width _ => (lib.memory width).getD unknown + | .ioGetInfo .. | .unconstrainedBigUintDivMod .. => #[pointerBound, pointerBound] + | _ => unknown + if bounds.size == op.outputs.size then bounds else unknown + +private def requiredBounds (lib : Library) (op : Operation) (bound : ValueId → Nat) : + Array (ValueId × Nat) := + match op.opcode with + | .u8BitDecomposition .. | .u8ShiftLeft .. | .u8ShiftRight .. | .u8Xor .. | .u8Add .. + | .u8Mul .. | .u8Sub .. | .u8And .. | .u8Or .. | .u8LessThan .. | .u8XorSplit7 .. + | .u8XorSplit4 .. | .u8RangeCheck .. | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. + | .u32ToField .. => op.inputs.map (·, 256) + | .u32LessThan .. => op.inputs.map (·, pointerBound) + -- Operands are resolved value ids in `Op.inputs` order: the load pointer is + -- the only operand, the I/O index follows the channel, and `ioSetInfo` + -- ends with its index and length. + | .load .. => (op.inputs[0]?.map (·, pointerBound)).toArray + | .ioRead .. => (op.inputs[1]?.map (·, pointerBound)).toArray + | .ioSetInfo .. => + (op.inputs.extract (op.inputs.size - 2) op.inputs.size).map (·, pointerBound) + | .assertEq xs _ _ => + (Array.range xs.size).flatMap fun i => + match op.inputs[i]?, op.inputs[i + xs.size]? with + | some x, some y => #[(x, bound y), (y, bound x)] + | _, _ => #[] + | .call index _ _ false => + match lib.callee index with + | some bounds => op.inputs.zip bounds.inputs + | none => #[] + | _ => #[] + +private structure Analysis where + produced : Array Nat + required : Array Nat + /-- Pointwise maximum over returns; empty until the first return. -/ + outputs : Array Nat + /-- Every store site: the memory width and its operands' bounds. -/ + stores : Array (Nat × Array Nat) + +private def Analysis.bound (a : Analysis) (value : ValueId) : Nat := + min (a.produced[value]?.getD unbounded) (a.required[value]?.getD unbounded) + +private def constrain (required : Array Nat) (value : ValueId) (bound : Nat) : Array Nat := + required.modify value (min · bound) + +/-- Without a fallback arm, the discriminant is one of the case values. -/ +private def guardDiscriminant (discriminant : ValueId) (arms : Array (G × BlockPlan)) + (fallback : Option BlockPlan) (required : Array Nat) : Array Nat := + if fallback.isSome then required + else constrain required discriminant (arms.foldl (fun m (g, _) => max m g.n) 0 + 1) + +mutual + /-- Yields escaping a block to its enclosing continuation, in plan order. -/ + private partial def blockYields (block : BlockPlan) : Array (Array ValueId) := + match block.control with + | .returnRow .. => #[] + | .yieldRow _ values => #[values] + | .branch _ arms fallback _ _ => armYields arms fallback + | .continueWith _ _ _ _ _ _ _ continuation => blockYields continuation + + private partial def armYields (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) : + Array (Array ValueId) := + arms.foldl (fun yields (_, block) => yields ++ blockYields block) #[] ++ + (fallback.map blockYields).getD #[] +end + +mutual + private partial def produceBlock (plan : FunctionPlan) (lib : Library) + (block : BlockPlan) (a : Analysis) : Analysis := + let a := block.operations.foldl (init := a) fun a index => + match plan.operations[index]? with + | some op => + let bound := fun v => a.produced[v]?.getD unbounded + let bounds := producedBounds lib op bound + let stores := match op.opcode with + | .store .. => a.stores.push (op.inputs.size, op.inputs.map bound) + | _ => a.stores + let produced := (op.outputs.zip bounds).foldl (fun p (v, b) => p.set! v b) a.produced + { a with stores := stores, produced := produced } + | none => a + produceControl plan lib block.control a + + private partial def produceArms (plan : FunctionPlan) (lib : Library) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (a : Analysis) : Analysis := + let a := arms.foldl (fun a (_, block) => produceBlock plan lib block a) a + match fallback with + | some block => produceBlock plan lib block a + | none => a + + private partial def produceControl (plan : FunctionPlan) (lib : Library) + (control : Control) (a : Analysis) : Analysis := + match control with + | .returnRow _ values => + let bounds := values.map fun v => a.produced[v]?.getD unbounded + { a with outputs := if a.outputs.isEmpty then bounds + else (a.outputs.zip bounds).map fun (x, y) => max x y } + | .yieldRow .. => a + | .branch _ arms fallback _ _ => produceArms plan lib arms fallback a + | .continueWith _ arms fallback _ _ merges _ continuation => + let a := produceArms plan lib arms fallback a + let yields := armYields arms fallback + let produced := merges.zipIdx.foldl (init := a.produced) fun p (merge, i) => + p.set! merge (yields.foldl (init := 1) fun b values => + max b ((values[i]?.map fun v => a.produced[v]?.getD unbounded).getD unbounded)) + produceBlock plan lib continuation { a with produced } +end + +mutual + private partial def requireBlock (plan : FunctionPlan) (lib : Library) + (block : BlockPlan) (produced : Array Nat) (required : Array Nat) : Array Nat := + let required := block.operations.foldl (init := required) fun r index => + match plan.operations[index]? with + | some op => + (requiredBounds lib op fun v => produced[v]?.getD unbounded).foldl + (fun r (v, b) => constrain r v b) r + | none => r + requireControl plan lib block.control produced required + + private partial def requireArms (plan : FunctionPlan) (lib : Library) + (arms : Array (G × BlockPlan)) (fallback : Option BlockPlan) (produced : Array Nat) + (required : Array Nat) : Array Nat := + let required := arms.foldl (fun r (_, block) => requireBlock plan lib block produced r) required + match fallback with + | some block => requireBlock plan lib block produced required + | none => required + + private partial def requireControl (plan : FunctionPlan) (lib : Library) + (control : Control) (produced : Array Nat) (required : Array Nat) : Array Nat := + match control with + | .returnRow .. | .yieldRow .. => required + | .branch discriminant arms fallback _ _ => + requireArms plan lib arms fallback produced + (guardDiscriminant discriminant arms fallback required) + | .continueWith discriminant arms fallback _ _ merges _ continuation => + -- The continuation's uses of a merge bound every yield feeding it, so + -- the continuation is analyzed before the arms that yield into it. + let required := requireBlock plan lib continuation produced + (guardDiscriminant discriminant arms fallback required) + let required := (armYields arms fallback).foldl (init := required) fun r values => + (merges.zip values).foldl (fun r (merge, v) => constrain r v (r[merge]?.getD unbounded)) r + requireArms plan lib arms fallback produced required +end + +private def produce (plan : FunctionPlan) (lib : Library) : Analysis := + let unknown := Array.replicate plan.values.size unbounded + let a := produceBlock plan lib plan.body + { produced := unknown, required := unknown, outputs := #[], stores := #[] } + if a.outputs.isEmpty then { a with outputs := Array.replicate (plan.outputSize.getD 0) unbounded } else a + +private def analyze (plan : FunctionPlan) (lib : Library) : Analysis × FunctionBounds := + let a := produce plan lib + let a := { a with required := requireBlock plan lib plan.body a.produced a.required } + -- Input values are allocated first, so input `i` is value `i`. + (a, { inputs := (Array.range plan.layout.inputSize).map a.bound, outputs := a.outputs }) + +/-- Bounds shared across functions are rounded to width classes so that both +library fixpoints range over a finite lattice. -/ +private def roundBound (bound : Nat) : Nat := + if bound ≤ 256 then 256 else if bound ≤ 65536 then 65536 + else if bound ≤ 4294967296 then 4294967296 else unbounded + +/-- One width per seed word: the multiplicity stays full, inputs and read +results take their value bounds, and a slot shared by mutually exclusive +reads takes the widest. Unused slots are always zero and pack as one byte. -/ +private def seedSchema (plan : FunctionPlan) (a : Analysis) : SeedSchema := Id.run do + let mut bounds := Array.replicate plan.seedWords 1 + bounds := bounds.set! 0 unbounded + for i in [:plan.layout.inputSize] do + bounds := bounds.modify (1 + i) (max · (a.bound i)) + for op in plan.operations do + if let some read := op.externalRead then + for j in [:op.outputs.size] do + bounds := bounds.modify (read.seed.start + j) (max · (a.bound op.outputs[j]!)) + return SeedSchema.ofWidths (bounds.map SeedWidth.ofBound) + +/-- Joins every store site's operand bounds per memory width, rounded. -/ +private def memoryBounds (stores : Array (Nat × Array Nat)) : Array (Nat × Array Nat) := + stores.foldl (init := #[]) fun table (width, bounds) => + let bounds := bounds.map roundBound + match table.findIdx? (·.1 == width) with + | some i => table.modify i fun (width, joined) => + (width, (joined.zip bounds).map fun (x, y) => max x y) + | none => table.push (width, bounds) + +/-- Recomputes every schema with bounds shared across the library. + +Output and memory bounds are the least fixpoint, iterated upward from the +smallest class: a recursive function whose returns are its own call results +or byte results then narrows to bytes, and a table only ever stored with +bytes loads bytes, which a downward iteration from unknown never would. +Every finite execution is covered by induction on its call depth, so the +limit is a valid bound; a phase that does not settle falls back to unknown. +Input bounds are then iterated downward from unknown, where every iterate is +already valid and stopping early is safe. -/ +def resolveSchemas (functions : Array (Option FunctionPlan)) : Array (Option FunctionPlan) := Id.run do + let plans := functions.filterMap id + let mut outputs : Array (Option (Array Nat)) := functions.map fun plan => plan.map fun plan => + Array.replicate (plan.outputSize.getD 0) 256 + -- Only tables with a store site have bounds; the rest stay unknown. + let mut memory : Array (Nat × Array Nat) := memoryBounds <| + (plans.foldl (fun stores plan => stores ++ (produce plan Library.empty).stores) #[]).map + fun (width, bounds) => (width, bounds.map fun _ => 256) + let mut settled := false + for _ in [:64] do + let lib : Library := { + callee := fun index => (outputs[index]?.join).map fun outputs => { inputs := #[], outputs } + memory := fun width => (memory.find? (·.1 == width)).map (·.2) } + let analyses := functions.map fun plan => plan.map fun plan => produce plan lib + let nextOutputs := analyses.map fun a => a.map fun a => a.outputs.map roundBound + let nextMemory := memoryBounds <| + analyses.foldl (fun stores a => stores ++ (a.map (·.stores)).getD #[]) #[] + if nextOutputs == outputs && nextMemory == memory then + settled := true + break + outputs := nextOutputs + memory := nextMemory + unless settled do + outputs := functions.map fun plan => plan.map fun plan => + Array.replicate (plan.outputSize.getD 0) unbounded + memory := #[] + let mut inputs : Array (Option (Array Nat)) := functions.map fun plan => plan.map fun plan => + Array.replicate plan.layout.inputSize unbounded + let lib := fun (inputs : Array (Option (Array Nat))) => ({ + callee := fun index => + match inputs[index]?.join, outputs[index]?.join with + | some inputs, some outputs => some { inputs, outputs } + | _, _ => none + memory := fun width => (memory.find? (·.1 == width)).map (·.2) } : Library) + for _ in [:64] do + let next := functions.map fun plan => plan.map fun plan => + (analyze plan (lib inputs)).2.inputs.map roundBound + if next == inputs then break + inputs := next + return functions.map fun plan => plan.map fun plan => + { plan with seedSchema := seedSchema plan (analyze plan (lib inputs)).1 } + +def function (top : Toplevel) (index : FunIdx) : Except String FunctionPlan := do + let some definition := top.functions[index]? | throw s!"function {index} does not exist" + unless definition.constrained do throw s!"function {index} has no constrained trace" + let build : PlanM BlockResult := do + let mut inputs := #[] + for i in [:definition.layout.inputSize] do + let value ← newValue { degree := 1, input := some i } + inputs := inputs.push value + let scope : Scope := { + locals := inputs, degrees := Array.replicate inputs.size 1, seed := 1 + inputs.size } + planBlock top definition.layout scope none definition.body + let (result, state) ← (build.run {}).mapError fun error => s!"function {index}: {error}" + let computed : FunctionLayout := + { inputSize := definition.layout.inputSize, selectors := state.selectors.size, + auxiliaries := result.scope.auxiliary, lookups := result.scope.lookup } + unless computed == definition.layout do + throw s!"function {index}: planned layout {repr computed} differs from {repr definition.layout}" + let (_, oracle) := (Concrete.Bytecode.blockLayout definition.body).run + (Concrete.Bytecode.LayoutMState.new definition.layout.inputSize) + let oracleLayout := { oracle.functionLayout with lookups := oracle.functionLayout.lookups + 1 } + unless computed == oracleLayout do + throw s!"function {index}: trace plan differs from the layout allocator" + let reads := state.operations.filterMap fun op => op.externalRead.map fun _ => op.index + let (controlRoots, _) := preparationControls state.operations result.plan false + let preparationRoots := state.preparationRoots ++ controlRoots + let (rowOperations, rowValues) := dependencies state.values state.operations.size + state.rowRoots state.rowWrites false + let (preparationOperations, preparationValues) := dependencies state.values state.operations.size + preparationRoots reads true + let plan : FunctionPlan := { + index, layout := computed, outputSize := state.outputSize, body := result.plan, + values := state.values, operations := state.operations, seedWords := result.scope.seed + seedSchema := SeedSchema.canonical result.scope.seed + rowOperations, preparationOperations, rowValues, preparationValues } + -- Without the library, callees and memory contribute no bounds; `program` + -- refines this. + pure { plan with seedSchema := seedSchema plan (analyze plan Library.empty).1 } + +private def validateCircuits (top : Toplevel) : Except String Unit := do + let mut seen := Array.replicate top.functions.size false + for circuit in top.circuits do + if circuit.members.isEmpty then throw s!"circuit {circuit.name} has no members" + let mut merged : FunctionLayout := + { inputSize := 0, selectors := 0, auxiliaries := 0, lookups := 0 } + for member in circuit.members do + let some definition := top.functions[member]? + | throw s!"circuit {circuit.name}: missing member {member}" + unless definition.constrained do + throw s!"circuit {circuit.name}: member {member} is unconstrained" + if seen[member]! then throw s!"function {member} occurs in more than one circuit" + seen := seen.set! member true + merged := merged.merge definition.layout + unless merged == circuit.layout do + throw s!"circuit {circuit.name}: merged member layout differs from its declared layout" + for i in [:top.functions.size] do + unless seen[i]! == top.functions[i]!.constrained do + throw s!"constrained function {i} has no circuit" + +def program (top : Toplevel) : Except String ProgramPlan := do + if top.functions.size >= gSize.toNat then throw "function count exceeds the field characteristic" + for size in top.memorySizes do + if size >= gSize.toNat then throw "memory width exceeds the field characteristic" + validateCircuits top + let mut functions := #[] + for i in [:top.functions.size] do + if top.functions[i]!.constrained then + functions := functions.push (some (← function top i)) + else + functions := functions.push none + pure { functions := resolveSchemas functions, circuits := top.circuits } + +end Aiur.TracePlan + +end diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 5d4bf5ab7..ec7e0e235 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -124,7 +124,7 @@ private def runAggregateCmdNativeWith | .error e => IO.eprintln s!"aggregate failed: {e}"; return 1 | .ok address => -- The root (or subtree root) proof address, alone on stdout, is what - -- a driver reads; the log lines are on stderr. + -- a driver such as `ix prove --lanes` reads; the log lines are on stderr. if !address.isEmpty then IO.println address (← IO.getStdout).flush diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean index ba47d9064..9cd712c68 100644 --- a/Ix/Cli/CodegenCmd.lean +++ b/Ix/Cli/CodegenCmd.lean @@ -31,6 +31,8 @@ public import Cli public import Ix.Aggr public import Ix.Aiur.Compiler public import Ix.Aiur.Stages.Codegen +public import Ix.Aiur.Stages.TraceCodegen +public import Ix.Aiur.Stages.TraceCuda public import Ix.IxVM public import Ix.IxVM.Toplevel public import MultiStark @@ -47,6 +49,7 @@ structure Target where label : String source : Except Aiur.Global Aiur.Source.Toplevel outPath : String + groups : Array (String × Array String) def targets : List Target := [ -- the generated kernel is the kernel. Every consumer of @@ -54,14 +57,15 @@ def targets : List Target := [ -- table (CheckCmd / ProveCmd / VerifyCmd), or `funIdx` lookups -- resolve against a different function set than the generated code. { label := "ixvm", source := IxVM.ixVM, - outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs" }, + outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs", groups := IxVM.functionGroups }, { label := "multi-stark", source := MultiStark.multiStark, - outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs" }, + outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs", + groups := MultiStark.verifierFunctionGroups }, -- `ix aggregate` proving/verification must select the SAME toplevel for its -- function-index table (`Aggr.ixAggr`), or `ix_aggr` lookups resolve -- against a different function set than the generated code. { label := "ix-aggr", source := Aggr.ixAggr, - outPath := "crates/ixvm-codegen/src/aiur_ix_aggr.rs" } + outPath := "crates/ixvm-codegen/src/aiur_ix_aggr.rs", groups := Aggr.functionGroups } ] /-- Emit one target. In `--check` mode, compares against the on-disk file @@ -100,10 +104,138 @@ def emitTarget (checkOnly : Bool) (t : Target) : IO Bool := do ({compiled.bytecode.functions.size} aiur fns)" return true +/-- Circuits generated beyond the static rule, by circuit name per target: +the IxVM circuits whose host trace building dominates a proof, small rows +in very large numbers whose typed seed is a fraction of the row. The list +was chosen from one environment's measurements; revisit it when a heavier +one is profiled. -/ +def weightedCircuits : List (String × Array String) := [ + ("ixvm", #[ + "blake3_compress_chunks", "get_tagn4", "get_u64_le", "g_list_has", "list_snoc.G", + "expr_glb_walk", "expr_inst_many_walk", "get_app_telescope", "expr_glb", "expr_lower", + "get_expr", "expr_lbr", "k_infer_app_spine_loop", "list_drop.G", "expr_inst_many_bvar", + "expr_lower_walk", "bytes_to_block", "expr_inst_many", "get_expr_list", "collect_spine", + "list_concat.G", "apply_spine", "list_lookup.Ptr.KExprNode", "ixvm_group_24"])] + +/-- The production selection: `blake3_compress`, every circuit whose members +pack into at most half their canonical seeds +(`ProgramPlan.compactCircuitFunctions`), and the measured `weightedCircuits`. +Every selected writer is generated from the same bytecode library as its +host seed packer. -/ +def traceBundle : Except String (Array (String × String)) := do + let mut files := #[] + let mut units := #[] + for target in targets do + let source ← target.source.mapError fun error => s!"{target.label}: {repr error}" + let compiled ← source.compile + let grouped ← compiled.groupFunctions target.groups + let some function := compiled.getFuncIdx `blake3_compress + | throw s!"{target.label}: missing blake3_compress" + let plan ← (TracePlan.program grouped.bytecode).mapError fun error => s!"{target.label}: {error}" + let mut chosen := plan.compactCircuitFunctions.push function + -- A weighted name is a function (any of its aliases; its whole circuit + -- is taken) or a group circuit's name. + for name in (weightedCircuits.lookup target.label).getD #[] do + let circuit := match compiled.getFuncIdx (String.toName name) with + | some index => + grouped.bytecode.circuits.find? fun (c : Bytecode.Circuit) => c.members.contains index + | none => grouped.bytecode.circuits.find? fun (c : Bytecode.Circuit) => c.name == name + let some circuit := circuit + | throw s!"{target.label}: no function or circuit named {name} in the weighted selection" + chosen := chosen ++ circuit.members + let selected := some ((chosen.toList.eraseDups.toArray).qsort (· < ·)) + let unit := target.label.replace "-" "_" + let cuda ← TraceCuda.emit grouped.bytecode unit selected + let path := s!"cuda/generated/production/{unit}.cu" + let digest := (Blake3.Rust.hash cuda.toUTF8).val.data.map fun n => Lean.toJson n.toNat + units := units.push (Lean.Json.mkObj [("source", Lean.toJson path), ("digest", Lean.Json.arr digest)]) + files := files ++ #[ + (s!"crates/aiur/src/trace_codegen/programs/{unit}.rs", ← TraceCodegen.emit grouped.bytecode "crate" selected), + (s!"crates/aiur/src/trace_codegen/programs/{unit}_cuda.rs", ← TraceCuda.registry grouped.bytecode unit "crate" selected), + (s!"crates/aiur/{path}", cuda)] + let manifest := Lean.Json.mkObj [("abi", Lean.toJson (2 : Nat)), ("units", Lean.Json.arr units)] + pure (files.push ("crates/aiur/cuda/generated/production/trace-manifest.json", manifest.pretty ++ "\n")) + +def emitTraceBundle (checkOnly : Bool) : IO UInt32 := do + let files ← match traceBundle with + | .ok files => pure files + | .error error => IO.eprintln s!"trace bundle: {error}"; return 1 + for (path, source) in files do + if checkOnly then + let existing ← try pure (some (← IO.FS.readFile path)) catch _ => pure none + unless existing == some source do + IO.eprintln s!"{path} is missing or stale; run ix codegen --trace-bundle" + return 1 + else + if let some parent := (System.FilePath.mk path).parent then IO.FS.createDirAll parent + IO.FS.writeFile path source + IO.println s!"{path}: {source.utf8ByteSize} bytes" + return 0 + def runCodegenCmd (p : Cli.Parsed) : IO UInt32 := do let checkOnly := p.hasFlag "check" + let traceRust := p.hasFlag "trace-rust" + let traceCuda := p.hasFlag "trace-cuda" + let traceRegistry := p.hasFlag "trace-cuda-registry" + let bundle := p.hasFlag "trace-bundle" + if (#[checkOnly && !bundle, bundle, traceRust, traceCuda, traceRegistry].filter id).size > 1 then + IO.eprintln "Select one codegen mode: --check, --trace-bundle [--check], --trace-rust, --trace-cuda, or --trace-cuda-registry" + return 1 + if bundle then + if p.hasFlag "target" || p.hasFlag "trace-functions" then + IO.eprintln "--trace-bundle emits the production selection for all three targets" + return 1 + return ← emitTraceBundle checkOnly + let selected ← match (p.flag? "target").map (·.as! String) with + | none => pure targets + | some label => + let selected := targets.filter (·.label == label) + if selected.isEmpty then + IO.eprintln s!"Unknown codegen target {label}; expected ixvm, multi-stark, or ix-aggr" + return 1 + pure selected + if traceCuda || traceRegistry then + let [target] := selected | do + IO.eprintln "CUDA emission requires one --target" + return 1 + let some functions := (p.flag? "trace-functions").map (·.as! String) | do + IO.eprintln "CUDA emission requires --trace-functions with comma-separated constrained function indices" + return 1 + let emitted : Except String String := do + let mut indices := #[] + for item in functions.splitOn "," do + let some index := item.trimAscii.toString.toNat? | throw s!"invalid function index {item}" + indices := indices.push index + let source ← target.source.mapError (fun error => s!"{repr error}") + let compiled ← source.compile + let grouped ← compiled.groupFunctions target.groups + let unit := target.label.replace "-" "_" + if traceCuda then Aiur.TraceCuda.emit grouped.bytecode unit (some indices) + else Aiur.TraceCuda.registry grouped.bytecode unit "aiur" (some indices) + match emitted with + | .ok source => IO.print source; return 0 + | .error error => IO.eprintln s!"{target.label} CUDA codegen: {error}"; return 1 + if traceRust then + let [target] := selected | do + IO.eprintln "--trace-rust requires one --target" + return 1 + let emitted : Except String String := do + let mut selected := none + if let some functions := (p.flag? "trace-functions").map (·.as! String) then + let mut indices := #[] + for item in functions.splitOn "," do + let some index := item.trimAscii.toString.toNat? | throw s!"invalid function index {item}" + indices := indices.push index + selected := some indices + let source ← target.source.mapError (fun error => s!"{repr error}") + let compiled ← source.compile + let grouped ← compiled.groupFunctions target.groups + Aiur.TraceCodegen.emit grouped.bytecode "aiur" selected + match emitted with + | .ok source => IO.print source; return 0 + | .error error => IO.eprintln s!"{target.label} trace codegen: {error}"; return 1 let mut ok := true - for t in targets do + for t in selected do ok := (← emitTarget checkOnly t) && ok return if ok then 0 else 1 @@ -115,7 +247,13 @@ def codegenCmd : Cli.Cmd := `[Cli| "Compile the IxVM kernel, MultiStark verifier, and single-entrypoint ixAggr system to Rust via the Bytecode → Rust codegen pass (fixed output paths, no override). PARITY UNVERIFIED — run their generated/interpreter fixture checks before trusting any witness." FLAGS: - "check"; "CI mode: compare all three emitted sources (`aiur_ixvm.rs`, `aiur_multi_stark.rs`, `aiur_ix_aggr.rs`) against disk and exit 0 if identical, 1 otherwise. Does not modify files." + "trace-bundle"; "Generate production CUDA units, host seed writers, and registry manifests for all three programs; --check detects stale files." + "check"; "Compare selected emitted Rust sources against disk and exit 0 if identical, 1 otherwise. Does not modify files." + "trace-cuda"; "Emit CUDA row writers for --trace-functions in one --target." + "trace-cuda-registry"; "Emit the Rust registry for the same CUDA function selection." + "trace-functions" : String; "Comma-separated constrained function indices required for CUDA emission." + "trace-rust"; "Emit experimental scalar trace writers and read-only seed packers to stdout for one --target." + "target" : String; "Select ixvm, multi-stark, or ix-aggr (default: all three)." ] end diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 68457586b..77f67edf4 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -28,6 +28,7 @@ module public import Cli public import Ix.Aiur.Compiler public import Ix.Aiur.Protocol +public import Ix.Aggr public import Ix.Claim public import Ix.Shard.Check public import Ix.Shard.Environment @@ -290,6 +291,48 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList + -- N GPUs: one child process per device over its share of the Stage 2 + -- plan, then the final joins (see `Ix.Cli.Lanes`). Dispatched before + -- any prover system is built, so this process opens no device. + if let some lanes := (p.flag? "lanes").map (·.as! Nat) then + let some ixe := ixePath | IO.eprintln "--lanes requires --ixe"; return 1 + let some manifest := (p.flag? "ixes").map (·.as! String) + | IO.eprintln "--lanes requires --ixes"; return 1 + if !traceShards then + IO.eprintln "--lanes requires --trace-shards"; return 1 + if p.hasFlag "shards" || p.hasFlag "shard" || p.hasFlag "distributed" || execOnly then + IO.eprintln "--lanes cannot be combined with --shard, --shards, --distributed or --exec-only" + return 1 + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + -- Both prover systems are built once here; Rust derives a resident + -- pair per GPU from them without copying the bytecode again. + let ixvmCompiled ← match IxVM.ixVM with + | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1 + | .ok t => match t.compileWithGroups IxVM.functionGroups with + | .error e => IO.eprintln s!"compilation failed: {e}"; return 1 + | .ok c => pure c + let aggrCompiled ← match Aggr.ixAggr with + | .error e => IO.eprintln s!"ixAggr toplevel merge failed: {e}"; return 1 + | .ok t => match t.compileWithGroups Aggr.functionGroups with + | .error e => IO.eprintln s!"ixAggr compilation failed: {e}"; return 1 + | .ok c => pure c + let rp := Aggr.defaultRecursionParameters + let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode commitmentParameters friParameters + let aggrSystem := Aiur.AiurSystem.build aggrCompiled.bytecode rp.commitment rp.fri + let some verifyIdx := ixvmCompiled.getFuncIdx `verify_claim + | IO.eprintln "compiled toplevel has no `verify_claim` entry"; return 1 + let some aggrIdx := aggrCompiled.getFuncIdx `ix_aggr + | IO.eprintln "compiled ixAggr has no `ix_aggr` entry"; return 1 + let result ← IO.lazyPure fun _ => + Aiur.AiurSystem.proveLanes ixvmSystem aggrSystem envHandle manifest + verifyIdx aggrIdx lanes maxRamBytes + (((p.flag? "exec-jobs").map (·.as! Nat)).getD 0) 0 rp.cacheFriBytes + (outIxes.getD "") + match result with + | .error e => IO.eprintln s!"[lanes] {e}"; return 1 + | .ok root => IO.println root; return 0 let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1 | .ok t => pure t @@ -496,7 +539,8 @@ def proveCmd : Cli.Cmd := `[Cli| "retention" : String; "With --trace-shards: what the batch keeps between its two rounds — `retain` (every shard's stage 1, nothing recomputed), `regenerate` (headers only; each shard rebuilt for round two), or `auto` (default: retain when the RAM model says the retained batch fits --max-ram). Fixing it lets one plan be measured under both policies." "distributed"; "With --ixes and no --shard: prove the WHOLE environment as one `CheckEnv` claim, with one worker record per chunk — each shard of the manifest is one worker's chunk, the constants it owns — executing in parallel (calls into other workers' constants cross records through the lookup argument) and every record's trace shards in one batch. Writes one proof; no manifest is refined." "cells" : Nat; "With --distributed: per-shard committed-cell budget each worker record is planned to (e.g. 1800000000 for a 96 GB device). 0 (default) proves each record as one shard." - "exec-jobs" : Nat; "With --ixes and --trace-shards: how many shards execute at once ahead of the prover (default 0: one per core); peak host memory is the prover's budget plus the records in flight. With --distributed: how many workers execute at once (default 0: one per core). Workers are proven in an order that lets each commit as soon as its callers have executed; a committed record is dropped and re-executed for its second round." + "lanes" : Nat; "With --ixes and --trace-shards: prove on N GPUs using a shared execution pool. --max-ram and --exec-jobs are per-GPU values. Environment claims exceeding the 128 GiB record ceiling (AIUR_RECORD_MAX_BYTES overrides it) are bisected automatically. Rerunning resumes the checkpointed partition and completed proofs. --out-ixes writes the final partition. Prints the verified root address on stdout." + "exec-jobs" : Nat; "With --ixes and --trace-shards: how many shards execute at once ahead of the prover (default 0: one per core, or each worker's share of the cores with --lanes); peak host memory is the prover's budget plus the records in flight. With --distributed: how many workers execute at once (default 0: one per core). Workers are proven in an order that lets each commit as soon as its callers have executed; a committed record is dropped and re-executed for its second round." "plan-only"; "With --distributed: report the static caller graph, the commit order and the largest group of mutually calling workers (how many records the first round holds at once) for this manifest, and stop before executing anything. The way to compare layouts without a run." "skip-proven"; "With --ixes: before executing a leaf, look its claim up in the shard-proof index (`~/.ix/cache/shard-proofs/`); a recorded proof that decodes, bundles exactly that claim and verifies natively is reused — its address printed, nothing executed — instead of proving again. How a partially proved partition resumes after a refinement." "no-index"; "Neither read nor write the shard-proof index (every persisted proof is normally recorded there under its claim digest)." diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index f7f5c4bd7..02c2929df 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -211,7 +211,7 @@ def shardCmd : Cli.Cmd := `[Cli| shards : Nat; "Fixed number of shards N (static strategy; overrides --max-ram sizing and the profiled default budget sizing)" "max-cycles" : Nat; "Per-shard guest-cycle budget (profiled strategy only)" "max-ram" : Nat; "Per-shard prover-RAM budget, GiB. Static strategy: seed the shard count from the `.ixe` block-shape score (serialized block size + a superlinear large-body term). A CUDA build seeds for the trace-shard prover by serialized block bytes, against one execution's share of the record budget (this budget less the prover's working set at AIUR_TRACE_SHARD_MAX_CELLS, over --exec-jobs + 2), anchored at the 78-shard Mathlib cut proven on four GPUs (execution records are close to linear in owned bytes); a CPU build seeds with the CPU prover's fitted scale and budget exponents anchored at Mathlib. The record cap or the execution gate corrects every boundary. Profiled strategy: budget from measured op counters (default: detected system RAM)." - "exec-jobs" : Nat; "CUDA build, static strategy with --max-ram: the claim executions ahead of each prover the run will use (`ix prove --exec-jobs`), which sets the record share the seed fits (default 3, the calibration's)." + "exec-jobs" : Nat; "CUDA build, static strategy with --max-ram: the claim executions ahead of each prover the run will use (`ix prove --lanes --exec-jobs`), which sets the record share the seed fits (default 3, the calibration's)." balance : Nat; "Per-bisection balance tolerance, percent (default 5)" ordered; "Static strategy: lay the shards out as contiguous ranges of a dependency order instead of a min-cut, shard 0 at the top, so each shard's reference closure lies in its own shard and later ones. The layout `ix prove --distributed` wants, where each shard is one worker's chunk: the records then commit one at a time in chunk order." parallelism : Nat; "Provers assumed for the prove-time estimate (profiled strategy only; default 1 = sequential)" diff --git a/Ix/Cli/ShardProofIndex.lean b/Ix/Cli/ShardProofIndex.lean index 500ac2aa9..b708d7173 100644 --- a/Ix/Cli/ShardProofIndex.lean +++ b/Ix/Cli/ShardProofIndex.lean @@ -40,9 +40,11 @@ def readAddress (dir : System.FilePath) (digest : Address) : IO (Option Address) pure (Address.fromString raw.trimAscii.toString) catch _ => pure none -/-- Atomically replace one index entry. -/ +/-- Atomically replace one index entry. The temporary name carries the pid + so concurrent writers of one digest never share it. -/ def writeAddress (dir : System.FilePath) (digest addr : Address) : IO Unit := do - let tmp := dir / s!"{digest}.tmp" + let pid ← IO.Process.getPID + let tmp := dir / s!"{digest}.tmp.{pid}" IO.FS.writeFile tmp s!"{addr}\n" IO.FS.rename tmp (dir / toString digest) diff --git a/Ix/Store.lean b/Ix/Store.lean index 50a6155a8..b9066f0f4 100644 --- a/Ix/Store.lean +++ b/Ix/Store.lean @@ -61,10 +61,21 @@ def storePath (addr: Address): StoreIO FilePath := do IO.toEIO .ioError (IO.FS.createDirAll path) return path / file +/-- Write `bytes` to `path` through a temporary name unique to this + process and moment, then rename: a reader never sees a partial object, + and concurrent writers of one object each move a complete copy into + place. -/ +private def publish (path : System.FilePath) (bytes : ByteArray) : IO Unit := do + let pid ← IO.Process.getPID + let stamp ← IO.monoNanosNow + let tmp := System.FilePath.mk s!"{path}.tmp.{pid}.{stamp}" + IO.FS.writeBinFile tmp bytes + IO.FS.rename tmp path + def write (bytes: ByteArray) : StoreIO Address := do let addr := Address.blake3 bytes let path <- storePath addr - let _ <- IO.toEIO .ioError (IO.FS.writeBinFile path bytes) + let _ <- IO.toEIO .ioError (publish path bytes) return addr /-- Persist `bytes` keyed by an explicit caller-supplied address. Used @@ -73,7 +84,7 @@ def write (bytes: ByteArray) : StoreIO Address := do byte-serialization hash. -/ def writeAt (addr: Address) (bytes: ByteArray) : StoreIO Unit := do let path <- storePath addr - IO.toEIO .ioError (IO.FS.writeBinFile path bytes) + IO.toEIO .ioError (publish path bytes) def read (a: Address) : StoreIO ByteArray := do let path <- storePath a diff --git a/README.md b/README.md index 8cac0b8ce..fe22e0920 100644 --- a/README.md +++ b/README.md @@ -196,9 +196,12 @@ Rust consumers can instead enable the `cuda` feature on `aiur` or `ix-ffi`. The backend requires an NVIDIA GPU and a CUDA toolkit with `nvcc`; build and architecture controls are documented in the multi-stark repository. It keeps the Goldilocks/BLAKE3 protocol and proof format unchanged, and GPU proofs remain -verifiable by the CPU implementation. Dated hardware measurements belong in -[BENCHMARKS.md](BENCHMARKS.md) and [docs/benchmarking.md](docs/benchmarking.md), -not this stable overview. +verifiable by the CPU implementation. Proving a whole environment across +several GPUs (`ix prove --lanes`), generating traces on the device, and +benchmarking such runs are covered in +[docs/aiur-gpu-proving.md](docs/aiur-gpu-proving.md). Dated hardware +measurements belong in [BENCHMARKS.md](BENCHMARKS.md) and +[docs/benchmarking.md](docs/benchmarking.md), not this stable overview. ## Usage diff --git a/Tests/Aiur.lean b/Tests/Aiur.lean index dcdafc545..4c3000f87 100644 --- a/Tests/Aiur.lean +++ b/Tests/Aiur.lean @@ -3,6 +3,7 @@ module public import Tests.Aiur.Common public import Tests.Aiur.Aiur public import Tests.Aiur.Cost +public import Tests.Aiur.TracePlan public import Tests.Aiur.Hashes public import Tests.Aiur.RBTreeMap public import Tests.Aiur.Cross diff --git a/Tests/Aiur/TraceCodegen.lean b/Tests/Aiur/TraceCodegen.lean new file mode 100644 index 000000000..c0978222c --- /dev/null +++ b/Tests/Aiur/TraceCodegen.lean @@ -0,0 +1,172 @@ +module + +public import Ix.Aiur.Stages.TraceCodegen +public import Ix.Aiur.Compiler +public import Ix.IxVM.Toplevel + +public section + +namespace AiurTests.TraceCodegen + +open Aiur Aiur.Bytecode + +private def definition (inputs : Nat) (body : Block) (constrained : Bool := true) : Function := + let (_, state) := (Concrete.Bytecode.blockLayout body).run + (Concrete.Bytecode.LayoutMState.new inputs) + { body, entry := true, constrained, + layout := { state.functionLayout with lookups := state.functionLayout.lookups + 1 } } + +private def fields : Function := definition 2 { + ops := #[.add 0 1, .sub 0 1, .mul 0 1, .const 7, .mul 4 5, + .eqZero 6, .eqZero 0, .unconstrainedGInverse 0, .unconstrainedGToBytes 0], + ctrl := .return 0 #[] } + +private def bytes : Function := definition 2 { + ops := #[.u8BitDecomposition 0, .u8ShiftLeft 0, .u8ShiftRight 0, + .u8Xor 0 1, .u8Add 0 1, .u8Sub 0 1, .u8Mul 0 1, .u8And 0 1, + .u8Or 0 1, .u8LessThan 0 1, .u8XorSplit7 0 1, .u8XorSplit4 0 1, + .u8RangeCheck 0 1, .mul 14 16], + ctrl := .return 0 #[] } + +private def words : Function := definition 12 { + ops := #[.u32ToField #[0,1,2,3], .u32ToField #[4,5,6,7], .u32LessThan 12 13, + .unconstrainedU32Add #[0,1,2,3] #[4,5,6,7], + .unconstrainedU32Add3 #[0,1,2,3] #[4,5,6,7] #[8,9,10,11], .mul 19 24], + ctrl := .return 0 #[12,13,14,19,24] } + +private def branches : Function := definition 2 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.mul 1 1], ctrl := .yield 0 #[2] }), + (1, { ops := #[.u8Add 1 1], ctrl := .yield 1 #[2] })] + (some { ops := #[.eqZero 1], ctrl := .yield 2 #[2] }) + 1 4 1 { ops := #[.mul 2 1], ctrl := .return 3 #[3] } } + +private def memory : Function := definition 1 { + ops := #[.mul 0 0, .store #[0,1], .call 5 #[2] 1 false, .load 2 3, .add 4 5], + ctrl := .return 0 #[6] } + +private def identityFunction : Function := definition 1 { ops := #[], ctrl := .return 0 #[0] } + +private def aliasFunction : Function := definition 1 { + ops := #[.mul 0 0, .call 5 #[1] 1 false], ctrl := .return 0 #[2] } + +private def ioFunction : Function := definition 2 { + ops := #[.ioWrite 0 #[1], .ioGetInfo 0 #[1], .ioRead 0 2 2, + .const 999, .ioSetInfo 0 #[6] 2 3, .assertEq #[4] #[4] (some "quoted \"value\"\nλ"), + .debug "trace fixture" none], + ctrl := .return 0 #[4,5] } + +private def earlyReturn : Function := definition 1 { + ops := #[.mul 0 0], ctrl := .matchContinue 1 + #[(0, { ops := #[], ctrl := .return 0 #[] })] + (some { ops := #[], ctrl := .yield 1 #[] }) + 0 1 0 { ops := #[.load 1 0], ctrl := .return 2 #[] } } + +private def nestedEarlyReturn : Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[.mul 0 0] + ctrl := .match 1 + #[(0, { ops := #[], ctrl := .return 0 #[] })] + (some { ops := #[], ctrl := .yield 1 #[] }) })] + (some { ops := #[], ctrl := .yield 2 #[] }) + 0 2 0 { ops := #[.load 1 0], ctrl := .return 3 #[] } } + +private def branchReads : Function := definition 2 { + ops := #[.const 0], ctrl := .matchContinue 0 + #[(0, { ops := #[.ioRead 1 2 1], ctrl := .yield 0 #[3] })] + (some { ops := #[.ioRead 1 2 2], ctrl := .yield 1 #[4] }) + 1 3 0 { ops := #[.ioRead 1 3 1], ctrl := .return 2 #[4] } } + +private def bigUint : Function := definition 2 { + ops := #[.unconstrainedBigUintDivMod 0 1, .load 10 2], ctrl := .return 0 #[2,3] } + +private def constants : Function := definition 0 { + ops := #[.const 0, .eqZero 0, .const (G.ofNat (gSize.toNat - 1)), .eqZero 2], + ctrl := .return 0 #[] } + +private def unconstrainedFunction : Function := definition 1 { + ops := #[.unconstrainedGInverse 0], ctrl := .return 0 #[1] } false + +private def unconstrainedCaller : Function := definition 1 { + ops := #[.call 13 #[0] 1 true], ctrl := .return 0 #[1] } + +private def emptyCaller : Function := definition 1 { + ops := #[.mul 0 0, .call 16 #[] 0 false, .load 0 0, .ioRead 0 0 0], + ctrl := .return 0 #[] } + +private def emptyFunction : Function := definition 0 { ops := #[], ctrl := .return 0 #[] } + +private def nestedMergeRead : Function := definition 3 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[] + ctrl := .matchContinue 2 + #[(0, { ops := #[.const 0], ctrl := .yield 0 #[3] })] + (some { ops := #[.const 1], ctrl := .yield 1 #[3] }) + 1 1 0 { ops := #[.add 3 2], ctrl := .yield 2 #[4] } })] + (some { ops := #[.const 2], ctrl := .yield 3 #[3] }) + 1 2 0 { ops := #[.ioRead 1 3 1], ctrl := .return 4 #[4] } } + +private def exhaustiveMatch : Function := definition 1 { + ops := #[], ctrl := .match 0 #[(0, { ops := #[], ctrl := .return 0 #[] })] none } + +mutual + private partial def reindexBlock (oldIndex newIndex : Nat) (block : Block) : Except String Block := do + let ops ← block.ops.mapM fun op => match op with + | .call index args size unc => + if index != oldIndex then throw "BLAKE3 fixture gained an external callee" + else pure (.call newIndex args size unc) + | _ => pure op + pure { ops, ctrl := ← reindexControl oldIndex newIndex block.ctrl } + private partial def reindexControl (oldIndex newIndex : Nat) : Ctrl → Except String Ctrl + | .match d arms fallback => do + pure (.match d (← arms.mapM fun (v, b) => return (v, ← reindexBlock oldIndex newIndex b)) + (← fallback.mapM (reindexBlock oldIndex newIndex))) + | .matchContinue d arms fallback n aux lookups continuation => do + pure (.matchContinue d (← arms.mapM fun (v, b) => return (v, ← reindexBlock oldIndex newIndex b)) + (← fallback.mapM (reindexBlock oldIndex newIndex)) n aux lookups + (← reindexBlock oldIndex newIndex continuation)) + | ctrl => pure ctrl +end + +def fixtureProgram : Except String Toplevel := do + let mut functions := #[fields, bytes, words, branches, memory, identityFunction, + aliasFunction, ioFunction, earlyReturn, nestedEarlyReturn, branchReads, bigUint, + constants, unconstrainedFunction, unconstrainedCaller, emptyCaller, emptyFunction] + let source ← IxVM.ixVM.mapError (fun error => s!"{repr error}") + let compiled ← source.compile + let some index := compiled.getFuncIdx `blake3_compress | throw "missing BLAKE3 function" + let function := compiled.bytecode.functions[index]! + functions := functions.push { function with + entry := true + body := ← reindexBlock index functions.size function.body } + functions := functions ++ #[nestedMergeRead, exhaustiveMatch, definition 12 { + ops := #[.unconstrainedU32Add #[0,1,2,3] #[4,5,6,7], + .unconstrainedU32Add3 #[0,1,2,3] #[4,5,6,7] #[8,9,10,11], .mul 16 21], + ctrl := .return 0 #[16,21,22] }] + let some multiply := compiled.getFuncIdx `u64_mul | throw "missing u64_mul function" + functions := functions.push { compiled.bytecode.functions[multiply]! with entry := true } + let mut circuits := #[{ + name := "mixed", members := #[0, 3, 12], + layout := fields.layout.merge branches.layout |>.merge constants.layout : Circuit }] + for i in [:functions.size] do + if functions[i]!.constrained && !(#[0,3,12]).contains i then + circuits := circuits.push { name := s!"function_{i}", members := #[i], layout := functions[i]!.layout } + pure { functions, memorySizes := #[0,1,2,10], circuits } + +def blake3Program : Except String Bytecode.Toplevel := do + let top ← fixtureProgram + let function := top.functions[17]! + let body ← reindexBlock 17 0 function.body + let function := { function with body } + pure { + functions := #[function], memorySizes := #[], + circuits := #[{ name := "blake3", members := #[0], layout := function.layout }] } + +def emitFixtures : Except String String := do + Aiur.TraceCodegen.emit (← fixtureProgram) "crate" + +end AiurTests.TraceCodegen + +end diff --git a/Tests/Aiur/TraceFixtures.lean b/Tests/Aiur/TraceFixtures.lean new file mode 100644 index 000000000..c0e42e0d9 --- /dev/null +++ b/Tests/Aiur/TraceFixtures.lean @@ -0,0 +1,43 @@ +import Tests.Aiur.TraceCodegen +import Ix.Aiur.Stages.TraceCuda + +/-! Regenerates the trace-codegen test fixtures: for the planner's fixture +program and the BLAKE3 library, the Rust seed packers and row writers under +`crates/aiur/src/trace_codegen/tests/`, the CUDA units under +`crates/aiur/cuda/generated/`, and the manifest that binds them. `--check` +compares instead of writing, as `ix codegen --trace-bundle --check` does +for the production units. -/ + +def main (args : List String) : IO UInt32 := do + unless args.isEmpty || args == ["--check"] do + IO.eprintln "Expected no arguments or --check" + return 1 + let files : Except String (Array (String × String)) := do + let mut files := #[] + let mut units := #[] + for (unit, top) in #[("fixtures", ← AiurTests.TraceCodegen.fixtureProgram), + ("blake3", ← AiurTests.TraceCodegen.blake3Program)] do + let stem := if unit == "fixtures" then "generated" else "blake3" + let cuda ← Aiur.TraceCuda.emit top unit + let digest := (Blake3.Rust.hash cuda.toUTF8).val.data.map fun n => Lean.toJson n.toNat + let path := s!"cuda/generated/{unit}.cu" + units := units.push (Lean.Json.mkObj [("source", Lean.toJson path), ("digest", Lean.Json.arr digest)]) + files := files ++ #[ + (s!"crates/aiur/src/trace_codegen/tests/{stem}.rs", ← Aiur.TraceCodegen.emit top "crate"), + (s!"crates/aiur/src/trace_codegen/tests/{stem}_cuda.rs", ← Aiur.TraceCuda.registry top unit "crate"), + (s!"crates/aiur/{path}", cuda)] + let manifest := Lean.Json.mkObj [("abi", Lean.toJson (2 : Nat)), ("units", Lean.Json.arr units)] + pure (files.push ("crates/aiur/cuda/trace-manifest.json", manifest.pretty ++ "\n")) + let files ← match files with + | .ok files => pure files + | .error error => IO.eprintln error; return 1 + for (path, source) in files do + if args == ["--check"] then + if (← IO.FS.readFile path) != source then + IO.eprintln s!"{path} is stale" + return 1 + else + if let some parent := (System.FilePath.mk path).parent then IO.FS.createDirAll parent + IO.FS.writeFile path source + IO.println s!"{path}: {source.utf8ByteSize} bytes" + return 0 diff --git a/Tests/Aiur/TracePlan.lean b/Tests/Aiur/TracePlan.lean new file mode 100644 index 000000000..cbf85d018 --- /dev/null +++ b/Tests/Aiur/TracePlan.lean @@ -0,0 +1,355 @@ +module + +public import LSpec +public import Ix.Aiur.Stages.TracePlan + +public section + +open LSpec Aiur Aiur.Bytecode Aiur.TracePlan + +namespace AiurTests.TracePlan + +private def definition (inputs : Nat) (body : Bytecode.Block) : Bytecode.Function := + let (_, state) := (Concrete.Bytecode.blockLayout body).run + (Concrete.Bytecode.LayoutMState.new inputs) + { body, entry := false, constrained := true, + layout := { state.functionLayout with lookups := state.functionLayout.lookups + 1 } } + +private def singletonProgram (functions : Array Bytecode.Function) + (memorySizes : Array Nat := #[]) : Bytecode.Toplevel := + { functions, memorySizes, circuits := functions.mapIdx fun index f => + { name := s!"function_{index}", members := #[index], layout := f.layout } } + +private def accepts (name : String) (top : Bytecode.Toplevel) + (check : FunctionPlan → Bool) : TestSeq := + match Aiur.TracePlan.function top 0 with + | .ok plan => test name (check plan) + | .error error => test s!"{name}: {error}" false + +private def rejects (name : String) (top : Bytecode.Toplevel) : TestSeq := + test name ((match Aiur.TracePlan.program top with + | .error _ => true + | .ok _ => false) : Bool) + +private def arithmetic : Bytecode.Function := definition 2 { + ops := #[.mul 0 1, .const 7, .mul 2 3, .eqZero 4, .const 0, .eqZero 6, + .u8Add 0 1, .unconstrainedU32Add #[0, 1, 0, 1] #[1, 0, 1, 0], + .u32ToField #[10, 11, 12, 13]], + ctrl := .return 0 #[15] } + +private def identityFunction : Bytecode.Function := definition 1 { + ops := #[], ctrl := .return 0 #[0] } + +private def returnedCall : Bytecode.Function := definition 1 { + ops := #[.mul 0 0, .add 1 0, .call 1 #[2] 1 false], + ctrl := .return 0 #[3] } + +private def callThenLoad : Bytecode.Function := definition 1 { + ops := #[.mul 0 0, .call 1 #[1] 1 false, .load 2 2], + ctrl := .return 0 #[4] } + +private def branchBody (sharedAux : Nat := 4) (sharedLookups : Nat := 1) + (continuationInput : Nat := 2) : Bytecode.Block := { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.mul 1 1], ctrl := .yield 0 #[2] }), + (1, { ops := #[.u8Add 1 1], ctrl := .yield 1 #[2] })] + (some { ops := #[.eqZero 1], ctrl := .yield 2 #[2] }) + 1 sharedAux sharedLookups + { ops := #[.mul continuationInput 1], ctrl := .return 3 #[3] } } + +private def nested : Bytecode.Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[], ctrl := .yield 0 #[0] })] none 1 0 0 + { ops := #[], ctrl := .yield 1 #[1] } })] + (some { ops := #[.const 2], ctrl := .yield 2 #[1] }) + 1 1 0 { ops := #[], ctrl := .return 3 #[1] } } + +private def earlyReturn : Bytecode.Function := definition 1 { + ops := #[.mul 0 0], ctrl := .matchContinue 1 + #[(0, { ops := #[], ctrl := .return 0 #[0] })] + (some { ops := #[], ctrl := .yield 1 #[] }) + 0 1 0 { ops := #[.load 1 0], ctrl := .return 2 #[2] } } + +private def branchReads : Bytecode.Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.ioRead 0 0 1], ctrl := .yield 0 #[1] })] + (some { ops := #[.ioRead 0 0 2], ctrl := .yield 1 #[2] }) + 1 3 0 { ops := #[.ioRead 0 1 1], ctrl := .return 2 #[2] } } + +private def nestedEarlyReturn : Bytecode.Function := definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { + ops := #[.mul 0 0], ctrl := .match 1 + #[(0, { ops := #[], ctrl := .return 0 #[0] })] + (some { ops := #[], ctrl := .yield 1 #[] }) })] + (some { ops := #[], ctrl := .yield 2 #[] }) + 0 2 0 { ops := #[.load 1 0], ctrl := .return 3 #[1] } } + +private def externalReads : Bytecode.Function := definition 1 { + ops := #[.store #[0], .load 1 1, .ioGetInfo 0 #[2], .ioRead 0 3 2, + .unconstrainedBigUintDivMod 1 2, .ioSetInfo 0 #[2] 3 4, .ioWrite 0 #[5, 6]], + ctrl := .return 0 #[7, 8] } + +private def grouped : Bytecode.Toplevel := { + functions := #[arithmetic, nested], memorySizes := #[], + circuits := #[{ + name := "group", members := #[0, 1], + layout := arithmetic.layout.merge nested.layout }] } + +private def hasBackwardDependencies (plan : FunctionPlan) : Bool := + (plan.values.mapIdx fun index value => + value.rowInputs.all (· < index) && value.preparationInputs.all (· < index)).all id + +def allocationTests : TestSeq := + accepts "degree-sensitive allocations and virtual carries" + (singletonProgram #[arithmetic]) (fun plan => + plan.layout.auxiliaries == 9 && plan.layout.lookups == 2 && + plan.operations.map (·.auxiliaries) == + #[⟨1, 1⟩, ⟨2, 0⟩, ⟨2, 0⟩, ⟨2, 2⟩, ⟨4, 0⟩, ⟨4, 0⟩, + ⟨4, 1⟩, ⟨5, 4⟩, ⟨9, 0⟩] && + plan.operations.map (·.outputs.size) == #[1, 1, 1, 1, 1, 1, 2, 5, 1]) ++ + accepts "unused auxiliary writes survive but virtual return expressions need no row work" + (singletonProgram #[arithmetic]) (fun plan => + plan.rowOperations == #[0, 1, 2, 3, 6, 7] && + plan.preparationOperations.isEmpty && plan.seedWords == 3) ++ + accepts "short branches reserve the maximum including default inverses" + (singletonProgram #[definition 2 (branchBody 4)]) (fun plan => + plan.layout.auxiliaries == 7 && plan.layout.lookups == 2 && + plan.layout.selectors == 4 && + plan.operations.map (·.auxiliaries) == #[⟨1, 1⟩, ⟨1, 1⟩, ⟨3, 2⟩, ⟨6, 1⟩] && + match plan.body.control with + | .continueWith _ _ _ inverses space merges columns _ => + inverses == ⟨1, 2⟩ && space.auxiliaries == ⟨1, 4⟩ && + space.lookups == ⟨1, 1⟩ && columns == ⟨5, 1⟩ && merges == #[6] + | _ => false) ++ + accepts "nested continuations consume their own yields and preserve the outer scope" + (singletonProgram #[nested]) (fun plan => + plan.layout.auxiliaries == 3 && plan.layout.selectors == 4 && + hasBackwardDependencies plan && + match plan.body.control with + | .continueWith _ _ _ _ _ merges columns _ => merges == #[3] && columns == ⟨2, 1⟩ + | _ => false) ++ + rejects "incorrect shared auxiliary reservation is rejected" + (singletonProgram #[definition 2 (branchBody 3)]) ++ + rejects "incorrect shared lookup reservation is rejected" + (singletonProgram #[definition 2 (branchBody 4 0)]) ++ + rejects "continuation cannot refer to a discarded branch local" + (singletonProgram #[definition 2 (branchBody 4 1 3)]) + +def preparationTests : TestSeq := + accepts "returned-call alias skips key arithmetic" + (singletonProgram #[returnedCall, identityFunction]) (fun plan => + plan.seedWords == 3 && plan.preparationOperations == #[2] && + plan.rowOperations == #[0, 2] && + plan.operations.filterMap (fun op => op.externalRead.map (·.kind)) == + #[.returnedCall 1]) ++ + accepts "call-result-to-load chain retains CPU key arithmetic" + (singletonProgram #[callThenLoad, identityFunction] #[2]) (fun plan => + plan.seedWords == 5 && plan.preparationOperations == #[0, 1, 2] && + plan.operations.filterMap (fun op => op.externalRead.map (·.kind)) == + #[.callResult 1, .loadValues 2] && + plan.operations.filterMap (fun op => op.externalRead.map (·.seed)) == + #[⟨2, 1⟩, ⟨3, 2⟩]) ++ + accepts "early return retains the branch decision guarding a continuation read" + (singletonProgram #[earlyReturn] #[1]) (fun plan => + plan.preparationOperations == #[0, 1] && plan.seedWords == 3) ++ + accepts "nested return retains its decision guarding an enclosing continuation read" + (singletonProgram #[nestedEarlyReturn] #[1]) (fun plan => + plan.preparationOperations == #[0, 1] && plan.seedWords == 3) ++ + accepts "branch seed slots overlap and continuation starts after the larger arm" + (singletonProgram #[branchReads]) (fun plan => + plan.seedWords == 5 && hasBackwardDependencies plan && + plan.operations.filterMap (fun op => op.externalRead.map (·.seed)) == + #[⟨2, 1⟩, ⟨2, 2⟩, ⟨4, 1⟩]) ++ + accepts "store, load, IO and BigUint are reads; execution-only effects have no seed" + (singletonProgram #[externalReads] #[1]) (fun plan => + plan.seedWords == 10 && plan.preparationOperations == #[0, 1, 2, 3, 4] && + plan.operations.filterMap (fun op => op.externalRead.map (·.kind)) == + #[.storePointer 1, .loadValues 1, .ioInfo, .ioValues 2, .bigUintResults]) ++ + accepts "zero-output calls allocate a lookup without a seed or a key recomputation" + (singletonProgram #[ + definition 1 { ops := #[.mul 0 0, .call 1 #[1] 0 false], ctrl := .return 0 #[] }, + definition 1 { ops := #[], ctrl := .return 0 #[] }]) (fun plan => + plan.layout.lookups == 2 && plan.seedWords == 2 && + plan.preparationOperations.isEmpty && plan.rowOperations == #[0]) ++ + accepts "unconstrained call results need advice but no call lookup" + (singletonProgram #[ + definition 1 { ops := #[.call 1 #[0] 1 true], ctrl := .return 0 #[1] }, + identityFunction]) (fun plan => + plan.layout.lookups == 1 && plan.layout.auxiliaries == 2 && plan.seedWords == 3) ++ + accepts "129 inputs and 32 aliased outputs have the BLAKE3 seed-word count" + (singletonProgram #[definition 129 { + ops := #[.call 0 (Array.range 129) 32 false], + ctrl := .return 0 (Array.range' 129 32) }]) (fun plan => + plan.seedWords == 162 && plan.canonicalSeedBytes == 1296) + +private def programPlan (top : Bytecode.Toplevel) (index : Nat) : Option FunctionPlan := + match Aiur.TracePlan.program top with + | .ok plan => plan.functions[index]?.join + | .error _ => none + +private def widths (plan : FunctionPlan) : Array SeedWidth := plan.seedSchema.widths + +private def exhaustiveThenFallback : Bytecode.Function := definition 2 { + ops := #[], ctrl := .match 0 + #[(0, { ops := #[], ctrl := .return 0 #[] }), + (300, { + ops := #[], ctrl := .match 1 + #[(1, { ops := #[], ctrl := .return 1 #[] })] + (some { ops := #[], ctrl := .return 2 #[] }) })] none } + +private def yieldsIntoByteUse : Bytecode.Function := definition 2 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[], ctrl := .yield 0 #[1] })] + (some { ops := #[.const 5], ctrl := .yield 1 #[2] }) + 1 1 0 { ops := #[.u8Xor 2 2], ctrl := .return 2 #[3] } } + +private def recursiveBytes : Bytecode.Function := definition 2 { + ops := #[], ctrl := .match 0 + #[(7, { ops := #[.u8Xor 1 1], ctrl := .return 0 #[2] })] + (some { ops := #[.const 1, .add 0 2, .call 0 #[3, 1] 1 false], ctrl := .return 1 #[4] }) } + +private def boundedArithmetic : Bytecode.Function := definition 1 { + ops := #[.u8Xor 0 0, .const 200, .add 1 2, .mul 3 3, .mul 4 4], + ctrl := .return 0 #[3, 4, 5] } + +private def callsBoundedArithmetic : Bytecode.Function := definition 1 { + ops := #[.call 1 #[0] 3 false], ctrl := .return 0 #[1, 2, 3] } + +private def byteIdentity : Bytecode.Function := definition 1 { + ops := #[.u8Xor 0 0], ctrl := .return 0 #[1] } + +private def callsByteIdentity : Bytecode.Function := definition 1 { + ops := #[.call 1 #[0] 1 false, .mul 1 1], ctrl := .return 0 #[2] } + +private def callsUnconstrained : Bytecode.Function := definition 1 { + ops := #[.call 1 #[0] 1 true], ctrl := .return 0 #[1] } + +/-- Singleton circuits for the constrained functions only. -/ +private def library (functions : Array Bytecode.Function) : Bytecode.Toplevel := + { functions, memorySizes := #[], + circuits := (functions.zipIdx.filter (·.1.constrained)).map fun (f, index) => + { name := s!"function_{index}", members := #[index], layout := f.layout } } + +private def programWidths (name : String) (functions : Array Bytecode.Function) + (expected : Array SeedWidth) (bytes : Nat) (memorySizes : Array Nat := #[]) : TestSeq := + test name ((match programPlan { library functions with memorySizes } 0 with + | some plan => widths plan == expected && plan.typedSeedBytes == bytes + | none => false) : Bool) + +/-- Stores a byte and a field element, then loads the pair back. -/ +private def storeThenLoad : Bytecode.Function := definition 2 { + ops := #[.u8Xor 0 0, .store #[2, 1], .load 2 3], ctrl := .return 0 #[4, 5] } + +/-- Loads from a table nothing in the library stores into. -/ +private def loadUnstored : Bytecode.Function := definition 1 { + ops := #[.load 2 0], ctrl := .return 0 #[1, 2] } + +/-- Stores a wide value into the slot another function stores a byte into. -/ +private def storeWide : Bytecode.Function := definition 1 { + ops := #[.store #[0, 0]], ctrl := .return 0 #[1] } + +/-- Loads through a continuation merge of input 1, after an arm-local +constant, so the pointer's bytecode index (2) is not its value id (3). -/ +private def loadThroughMerge : Bytecode.Function := definition 2 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[.const 7], ctrl := .yield 0 #[1] })] + (some { ops := #[], ctrl := .yield 1 #[1] }) + 1 1 0 { ops := #[.load 1 2], ctrl := .return 2 #[3] } } + +def schemaTests : TestSeq := + test "typed layout stores wider words first, aligned, padded to eight" + (let schema := SeedSchema.ofWidths #[.full, .u8, .u32, .u16, .full, .u8] + schema.offsets == #[0, 22, 16, 20, 8, 23] && schema.bytes == 24) ++ + test "an all-full schema is the canonical encoding" + ((SeedSchema.canonical 3).isCanonical && (SeedSchema.canonical 3).bytes == 24) ++ + accepts "byte operations narrow the inputs they consume" + (singletonProgram #[arithmetic]) (fun plan => + widths plan == #[.full, .u8, .u8] && plan.typedSeedBytes == 16) ++ + accepts "an exhaustive match bounds its discriminant, a fallback does not" + (singletonProgram #[exhaustiveThenFallback]) (fun plan => + widths plan == #[.full, .u16, .full] && plan.typedSeedBytes == 24) ++ + accepts "a byte use on one arm speculatively narrows the word on every arm" + (singletonProgram #[definition 2 (branchBody 4)]) (fun plan => + widths plan == #[.full, .full, .u8]) ++ + accepts "continuation uses bound the values every arm yields" + (singletonProgram #[yieldsIntoByteUse]) (fun plan => + widths plan == #[.full, .full, .u8]) ++ + -- The callee's byte use narrows the argument; 255 + 200 < 2^16, its square + -- is below 2^32, and the square of that is wide. + programWidths "constants and byte results bound sums and products through call results" + #[callsBoundedArithmetic, boundedArithmetic] #[.full, .u8, .u16, .u32, .full] 24 ++ + programWidths "call results take callee output bounds and arguments take callee input bounds" + #[callsByteIdentity, byteIdentity] #[.full, .u8, .u8] 16 ++ + programWidths "recursive returns reach the least fixpoint instead of staying wide" + #[recursiveBytes] #[.full, .full, .u8, .u8] 24 ++ + programWidths "unconstrained callees contribute no bounds" + #[callsUnconstrained, { byteIdentity with constrained := false }] #[.full, .full, .full] 24 ++ + -- Seed: multiplicity, the two inputs, the store pointer, the two loaded words. + programWidths "loads take the join of every store into their table; pointers are u32" + #[storeThenLoad] #[.full, .u8, .full, .u32, .u8, .full] 32 #[2] ++ + programWidths "a wide store elsewhere in the library widens the loaded slot" + #[storeThenLoad, storeWide] #[.full, .u8, .full, .u32, .full, .full] 40 #[2] ++ + programWidths "a table with no store site loads unknown values but its pointer is u32" + #[loadUnstored] #[.full, .u32, .full, .full] 32 #[2] ++ + programWidths "pointer bounds follow resolved operands through merges" + #[loadThroughMerge] #[.full, .full, .u32, .full] 32 #[1] + +def malformedTests : TestSeq := + rejects "invalid value index" + (singletonProgram #[definition 1 { ops := #[.mul 0 1], ctrl := .return 0 #[1] }]) ++ + rejects "invalid callee index" + (singletonProgram #[definition 1 { ops := #[.call 9 #[0] 1 false], ctrl := .return 0 #[1] }]) ++ + rejects "callee input arity mismatch" + (singletonProgram #[definition 1 { + ops := #[.call 1 #[] 1 false], ctrl := .return 0 #[1] }, identityFunction]) ++ + rejects "callee output arity mismatch" + (singletonProgram #[definition 1 { + ops := #[.call 1 #[0] 2 false], ctrl := .return 0 #[1, 2] }, identityFunction]) ++ + rejects "memory read without its table" + (singletonProgram #[definition 1 { ops := #[.load 2 0], ctrl := .return 0 #[1, 2] }]) ++ + rejects "u32 operands must have four bytes" + (singletonProgram #[definition 1 { + ops := #[.unconstrainedU32Add #[0] #[0, 0, 0, 0]], ctrl := .return 0 #[1] }]) ++ + rejects "yield cannot escape a function" + (singletonProgram #[definition 1 { ops := #[], ctrl := .yield 0 #[0] }]) ++ + rejects "yield arity must match its continuation" + (singletonProgram #[definition 1 { + ops := #[], ctrl := .matchContinue 0 + #[(0, { ops := #[], ctrl := .yield 0 #[] })] none 1 0 0 + { ops := #[], ctrl := .return 1 #[1] } }]) ++ + rejects "duplicate selector allocation" + (singletonProgram #[definition 1 { + ops := #[], ctrl := .match 0 #[(0, { ops := #[], ctrl := .return 0 #[0] })] + (some { ops := #[], ctrl := .return 0 #[0] }) }]) ++ + rejects "selector outside the declared region" + (singletonProgram #[definition 1 { ops := #[], ctrl := .return 1 #[0] }]) ++ + rejects "duplicate match cases" + (singletonProgram #[definition 1 { + ops := #[], ctrl := .match 0 + #[(0, { ops := #[], ctrl := .return 0 #[0] }), + (0, { ops := #[], ctrl := .return 1 #[0] })] none }]) + +def groupingTests : TestSeq := + test "grouped functions retain member plans and merge only circuit regions" + ((match Aiur.TracePlan.program grouped with + | .error _ => false + | .ok plan => plan.functions.size == 2 && grouped.circuits[0]!.layout == + { inputSize := 2, selectors := 5, auxiliaries := 9, lookups := 2 }) : Bool) ++ + rejects "missing constrained member" { grouped with circuits := #[] } ++ + rejects "duplicate circuit member" { grouped with + circuits := grouped.circuits ++ grouped.circuits } ++ + rejects "declared circuit layout must match its members" { grouped with + circuits := #[{ grouped.circuits[0]! with layout := arithmetic.layout }] } ++ + rejects "unconstrained function cannot be a circuit member" { grouped with + functions := #[{ arithmetic with constrained := false }, nested] } + + +def tests : TestSeq := allocationTests ++ preparationTests ++ schemaTests ++ + malformedTests ++ groupingTests + +end AiurTests.TracePlan + +end diff --git a/Tests/Main.lean b/Tests/Main.lean index 7e8f31335..da3bb15ea 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -115,6 +115,7 @@ def primarySuites : Std.HashMap String (List LSpec.TestSeq) := .ofList [ ("ground-unit", Tests.Ground.suite), ("aiur-cross", [AiurTests.Cross.tests]), ("aiur-cost", [AiurTests.Cost.tests]), + ("aiur-trace-plan", [AiurTests.TracePlan.tests]), ("prim-addrs", Tests.Ix.Kernel.PrimAddrs.suite), ("primitive-address-parity", Tests.Ix.Kernel.BuildPrimitives.paritySuite ++ Tests.Ix.Kernel.BuildPrimOrigs.paritySuite), diff --git a/crates/aiur/Cargo.toml b/crates/aiur/Cargo.toml index 9a95e5ecd..4343adc1e 100644 --- a/crates/aiur/Cargo.toml +++ b/crates/aiur/Cargo.toml @@ -5,6 +5,7 @@ edition.workspace = true license.workspace = true [dependencies] +blake3 = { workspace = true } bincode = { version = "2", features = ["serde"] } hashbrown = { workspace = true } indexmap = { workspace = true } @@ -14,7 +15,11 @@ num-bigint = { workspace = true } rayon = { workspace = true } rustc-hash = { workspace = true } tracing = { workspace = true } -tracing-texray = { workspace = true } +tracing-texray = { workspace = true, optional = true } + +[build-dependencies] +blake3 = { workspace = true } +serde_json = { workspace = true } [dev-dependencies] # Exercise the native MMCS at the same Plonky3 revision as multi-stark. @@ -23,9 +28,11 @@ p3-commit = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c8 p3-symmetric = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c83775a8076cc262ffc48a1fd7c" } [features] -default = [] +default = ["texray"] parallel = ["multi-stark/parallel"] cuda = ["multi-stark/cuda"] +cuda-trace-codegen = ["cuda"] +texray = ["dep:tracing-texray"] [lints] workspace = true diff --git a/crates/aiur/build.rs b/crates/aiur/build.rs new file mode 100644 index 000000000..d14c6d633 --- /dev/null +++ b/crates/aiur/build.rs @@ -0,0 +1,300 @@ +//! CUDA build isolation. +//! +//! This build script is deliberately a no-op unless Cargo enables the +//! `cuda` feature. Normal CPU builds therefore need neither nvcc nor CUDA +//! headers/libraries. + +use std::env; +use std::path::{Path, PathBuf}; +use std::process::Command; + +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rerun-if-env-changed=NVCC"); + println!("cargo:rerun-if-env-changed=CUDA_HOME"); + println!("cargo:rerun-if-env-changed=CUDA_PATH"); + println!("cargo:rerun-if-env-changed=MULTI_STARK_CUDA_ARCHS"); + + if env::var_os("CARGO_FEATURE_CUDA").is_none() { + return; + } + + assert_eq!( + env::var("CARGO_CFG_TARGET_OS").as_deref(), + Ok("linux"), + "the first-party CUDA backend currently supports Linux targets only" + ); + assert_eq!( + env::var("CARGO_CFG_TARGET_ARCH").as_deref(), + Ok("x86_64"), + "the first-party CUDA backend currently supports x86_64 targets only" + ); + + let nvcc = nvcc_path(); + let out_dir = + PathBuf::from(env::var_os("OUT_DIR").expect("Cargo did not set OUT_DIR")); + let library = out_dir.join("libaiur_trace_cuda.a"); + let architectures = cuda_architectures(&nvcc); + + // Every aiur CUDA source belongs to the generated trace writers; the bare + // `cuda` feature only enables multi-stark's device backend. + if env::var_os("CARGO_FEATURE_CUDA_TRACE_CODEGEN").is_none() { + return; + } + let include = env::var_os("DEP_MULTI_STARK_CUDA_INCLUDE") + .expect("cuda-trace-codegen requires multi-stark's shared CUDA field header metadata"); + let includes = vec![PathBuf::from("cuda"), PathBuf::from(&include)]; + let headers = [ + PathBuf::from("cuda/trace_runtime.cuh"), + PathBuf::from("cuda/trace_primitives.cuh"), + PathBuf::from(include).join("goldilocks.cuh"), + ]; + let mut sources = vec![PathBuf::from("cuda/trace_runtime.cu")]; + { + for manifest_path in [ + "cuda/trace-manifest.json", + "cuda/generated/production/trace-manifest.json", + ] { + println!("cargo:rerun-if-changed={manifest_path}"); + let manifest: serde_json::Value = serde_json::from_slice( + &std::fs::read(manifest_path).expect("missing trace manifest"), + ) + .expect("invalid trace manifest"); + assert_eq!( + manifest["abi"].as_u64(), + Some(2), + "unsupported trace manifest ABI" + ); + for unit in manifest["units"].as_array().expect("manifest units") { + let path = + PathBuf::from(unit["source"].as_str().expect("CUDA unit source")); + assert!( + path + .components() + .all(|c| matches!(c, std::path::Component::Normal(_))) + && path.starts_with("cuda/generated") + && path.extension().is_some_and(|e| e == "cu"), + "CUDA unit path must be inside cuda/generated" + ); + let bytes = std::fs::read(&path).expect("missing generated CUDA unit"); + let digest: Vec = serde_json::from_value(unit["digest"].clone()) + .expect("CUDA unit digest"); + assert_eq!( + blake3::hash(&bytes).as_bytes().as_slice(), + digest, + "generated CUDA unit differs from its manifest: {}", + path.display() + ); + assert!(!sources.contains(&path), "duplicate CUDA unit"); + sources.push(path); + } + } + } + let mut common = vec![ + "--std=c++17".to_owned(), + "--cudart=static".to_owned(), + "--default-stream=per-thread".to_owned(), + "-O3".to_owned(), + "-lineinfo".to_owned(), + "--compiler-options=-fPIC".to_owned(), + "--ptxas-options=-v".to_owned(), + ]; + for architecture in &architectures { + common.push(format!( + "-gencode=arch=compute_{architecture},code=sm_{architecture}" + )); + } + // Exact-architecture cubins avoid PTX newer than the installed driver. + let version = Command::new(&nvcc) + .arg("--version") + .output() + .expect("failed to query nvcc version"); + assert!(version.status.success(), "nvcc --version failed"); + let mut key = blake3::Hasher::new(); + key.update(&version.stdout); + key.update(nvcc.as_encoded_bytes()); + for arg in &common { + key.update(arg.as_bytes()); + key.update(&[0]); + } + for include in &includes { + key.update(include.as_os_str().as_encoded_bytes()); + key.update(&[0]); + } + for header in &headers { + println!("cargo:rerun-if-changed={}", header.display()); + key.update(&std::fs::read(header).expect("missing CUDA header")); + } + let mut objects = Vec::new(); + for source in sources { + println!("cargo:rerun-if-changed={}", source.display()); + let mut hash = key.clone(); + hash.update(&std::fs::read(&source).expect("missing CUDA source")); + let object = out_dir.join(format!("{}.o", hash.finalize().to_hex())); + if !object.is_file() { + let mut command = Command::new(&nvcc); + command.args(&common); + for include in &includes { + command.arg("-I").arg(include); + } + command.arg("-c").arg(&source).arg("-o").arg(&object); + let output = command.output().expect("failed to execute nvcc"); + std::io::Write::write_all(&mut std::io::stderr(), &output.stderr) + .unwrap(); + if !output.status.success() { + let _ = std::fs::remove_file(&object); + panic!("nvcc failed for {}: {}", source.display(), output.status); + } + } + objects.push(object); + } + let _ = std::fs::remove_file(&library); + let status = Command::new(&nvcc) + .arg("--lib") + .arg("-o") + .arg(&library) + .args(&objects) + .status() + .expect("failed to archive CUDA objects"); + assert!(status.success(), "nvcc archive failed: {status}"); + + println!("cargo:rustc-link-search=native={}", out_dir.display()); + println!("cargo:rustc-link-lib=static=aiur_trace_cuda"); + // Bundle the CUDA runtime into Rust staticlib consumers as well as normal + // Cargo binaries. Dynamic native dependencies are not propagated through + // a Rust staticlib to a foreign final linker (for example, Lean/Lake), + // which otherwise leaves the CUDA registration and runtime symbols + // unresolved. This remains entirely behind the `cuda` feature. + println!("cargo:rustc-link-lib=static=cudart_static"); + println!("cargo:rustc-link-lib=dylib=dl"); + println!("cargo:rustc-link-lib=dylib=rt"); + println!("cargo:rustc-link-lib=dylib=pthread"); + println!("cargo:rustc-link-lib=dylib=stdc++"); + + for directory in cuda_library_directories(&nvcc) { + if directory.is_dir() { + println!("cargo:rustc-link-search=native={}", directory.display()); + } + } +} + +fn nvcc_path() -> std::ffi::OsString { + if let Some(nvcc) = env::var_os("NVCC") { + return nvcc; + } + if let Some(root) = + env::var_os("CUDA_HOME").or_else(|| env::var_os("CUDA_PATH")) + { + let candidate = PathBuf::from(root).join("bin/nvcc"); + if candidate.is_file() { + return candidate.into_os_string(); + } + } + "nvcc".into() +} + +fn cuda_architectures(nvcc: &std::ffi::OsStr) -> Vec { + let supported = supported_architectures(nvcc); + let configured = env::var("MULTI_STARK_CUDA_ARCHS").ok().map_or_else( + || { + let preferred = ["80", "86", "89", "90", "100", "120"]; + let selected = preferred + .into_iter() + .filter(|architecture| { + supported.iter().any(|item| item == architecture) + }) + .collect::>(); + let defaults = if selected.is_empty() { + detect_nvidia_architectures().unwrap_or_else(|| "80".to_owned()) + } else { + selected.join(",") + }; + (defaults, false) + }, + |value| (value, true), + ); + let (configured, explicitly_configured) = configured; + let architectures: Vec<_> = configured + .split(',') + .map(str::trim) + .filter(|architecture| !architecture.is_empty()) + .map(|architecture| { + assert!( + (2..=3).contains(&architecture.len()) + && architecture.chars().all(|character| character.is_ascii_digit()), + "invalid CUDA architecture {architecture:?}; expected comma-separated numbers such as 80,90" + ); + assert!( + !explicitly_configured + || supported.is_empty() + || supported.iter().any(|item| item == architecture), + "nvcc does not support CUDA architecture sm_{architecture}" + ); + architecture.to_owned() + }) + .collect(); + assert!( + !architectures.is_empty(), + "MULTI_STARK_CUDA_ARCHS must contain at least one architecture" + ); + architectures +} + +fn supported_architectures(nvcc: &std::ffi::OsStr) -> Vec { + let Ok(output) = Command::new(nvcc).arg("--list-gpu-code").output() else { + return Vec::new(); + }; + if !output.status.success() { + return Vec::new(); + } + String::from_utf8_lossy(&output.stdout) + .split_whitespace() + .filter_map(|code| code.strip_prefix("sm_")) + .filter(|code| code.chars().all(|character| character.is_ascii_digit())) + .map(str::to_owned) + .collect() +} + +/// Detect the architecture of the installed GPU when building on the target +/// machine. This avoids requiring users to translate `nvidia-smi`'s `12.0` +/// compute capability into nvcc's `sm_120` spelling. Cross builds and hosts +/// without a visible GPU retain the portable sm_80 default and can still set +/// `MULTI_STARK_CUDA_ARCHS` explicitly. +fn detect_nvidia_architectures() -> Option { + let output = Command::new("nvidia-smi") + .args(["--query-gpu=compute_cap", "--format=csv,noheader"]) + .output() + .ok()?; + if !output.status.success() { + return None; + } + let capabilities = String::from_utf8(output.stdout).ok()?; + let mut architectures = capabilities + .lines() + .map(|capability| { + capability + .chars() + .filter(|character| character.is_ascii_digit()) + .collect::() + }) + .filter(|architecture| !architecture.is_empty()) + .collect::>(); + architectures.sort_unstable(); + architectures.dedup(); + (!architectures.is_empty()).then(|| architectures.join(",")) +} + +fn cuda_library_directories(nvcc: &std::ffi::OsStr) -> Vec { + let root = env::var_os("CUDA_HOME") + .or_else(|| env::var_os("CUDA_PATH")) + .map(PathBuf::from) + .or_else(|| { + let nvcc = Path::new(nvcc); + nvcc + .is_absolute() + .then(|| nvcc.parent()?.parent().map(Path::to_path_buf)) + .flatten() + }) + .unwrap_or_else(|| PathBuf::from("/usr/local/cuda")); + vec![root.join("lib64"), root.join("targets/x86_64-linux/lib")] +} diff --git a/crates/aiur/cuda/generated/blake3.cu b/crates/aiur/cuda/generated/blake3.cu new file mode 100644 index 000000000..7ca7ac7f3 --- /dev/null +++ b/crates/aiur/cuda/generated/blake3.cu @@ -0,0 +1,1649 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_blake3 { +using namespace aiur_trace; + +__device__ __constant__ uint64_t inverse_0_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_blake3_0 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_blake3_0(Seed_blake3_0 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_0_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_blake3_0(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_blake3_0 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_blake3_0(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_blake3_0(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_blake3_0<<>>(seeds, real, rows, layout, output, error); + else kernel_blake3_0<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_blake3_0(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_blake3_0); +} + +extern "C" const uint8_t* aiur_trace_blake3_contract() { + static const uint8_t hash[32] = {150, 101, 248, 224, 67, 209, 56, 216, 146, 162, 51, 114, 82, 15, 10, 181, 15, 234, 113, 117, 51, 141, 70, 70, 235, 90, 62, 221, 45, 109, 215, 133}; + return hash; +} +extern "C" const uint8_t* aiur_trace_blake3_schema() { + static const uint8_t hash[32] = {165, 236, 59, 122, 69, 236, 212, 8, 235, 101, 210, 121, 79, 173, 18, 133, 132, 143, 40, 15, 127, 74, 213, 46, 47, 206, 141, 20, 66, 201, 215, 160}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/fixtures.cu b/crates/aiur/cuda/generated/fixtures.cu new file mode 100644 index 000000000..222333384 --- /dev/null +++ b/crates/aiur/cuda/generated/fixtures.cu @@ -0,0 +1,3108 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_fixtures { +using namespace aiur_trace; + +template struct Seed_fixtures_0 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_0(Seed_fixtures_0 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_4 = goldilocks_mul(v_0, v_1); + row[layout.auxiliaries + 1] = v_4; + const uint64_t v_5 = 7ULL; + const uint64_t v_6 = goldilocks_mul(v_4, v_5); + const uint64_t v_7 = uint64_t(v_6 == 0); + row[layout.auxiliaries + 2] = inverse(v_6); + row[layout.auxiliaries + 3] = v_7; + const uint64_t v_8 = uint64_t(v_0 == 0); + row[layout.auxiliaries + 4] = inverse(v_0); + row[layout.auxiliaries + 5] = v_8; + const uint64_t v_9 = inverse(v_0); + row[layout.auxiliaries + 6] = v_9; + const uint64_t v_10 = ((v_0 >> 0) & 255ULL); + const uint64_t v_11 = ((v_0 >> 8) & 255ULL); + const uint64_t v_12 = ((v_0 >> 16) & 255ULL); + const uint64_t v_13 = ((v_0 >> 24) & 255ULL); + const uint64_t v_14 = ((v_0 >> 32) & 255ULL); + const uint64_t v_15 = ((v_0 >> 40) & 255ULL); + const uint64_t v_16 = ((v_0 >> 48) & 255ULL); + const uint64_t v_17 = ((v_0 >> 56) & 255ULL); + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_0(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_0 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_0(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_0(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_0<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_0<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_0(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_0); +} + +template struct Seed_fixtures_1 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_1(Seed_fixtures_1 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = ((v_0 >> 0) & 1ULL); + const uint64_t v_3 = ((v_0 >> 1) & 1ULL); + const uint64_t v_4 = ((v_0 >> 2) & 1ULL); + const uint64_t v_5 = ((v_0 >> 3) & 1ULL); + const uint64_t v_6 = ((v_0 >> 4) & 1ULL); + const uint64_t v_7 = ((v_0 >> 5) & 1ULL); + const uint64_t v_8 = ((v_0 >> 6) & 1ULL); + const uint64_t v_9 = ((v_0 >> 7) & 1ULL); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + const uint64_t v_10 = ((v_0 << 1) & 255ULL); + row[layout.auxiliaries + 9] = v_10; + const uint64_t v_11 = (v_0 >> 1); + row[layout.auxiliaries + 10] = v_11; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_12 = (v_0 ^ v_1); + row[layout.auxiliaries + 11] = v_12; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_13 = ((v_0 + v_1) & 255ULL); + const uint64_t v_14 = ((v_0 + v_1) >> 8); + row[layout.auxiliaries + 12] = v_13; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_15 = ((v_0 - v_1) & 255ULL); + const uint64_t v_16 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 13] = v_15; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_17 = ((v_0 * v_1) & 255ULL); + const uint64_t v_18 = ((v_0 * v_1) >> 8); + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_19 = (v_0 & v_1); + row[layout.auxiliaries + 16] = v_19; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_20 = (v_0 | v_1); + row[layout.auxiliaries + 17] = v_20; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_21 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 18] = v_21; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_22 = ((v_0 ^ v_1) >> 7); + const uint64_t v_23 = (((v_0 ^ v_1) << 1) & 255ULL); + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_24 = ((v_0 ^ v_1) >> 4); + const uint64_t v_25 = (((v_0 ^ v_1) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_24; + row[layout.auxiliaries + 22] = v_25; + const uint64_t v_26 = goldilocks_mul(v_14, v_16); + row[layout.auxiliaries + 23] = v_26; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_1(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 24; + const Seed_fixtures_1 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_1(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_1(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_1<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_1<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_1(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 24) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_1); +} + +template struct Seed_fixtures_2 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_2(Seed_fixtures_2 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = canonicalize(word(v_0, v_1, v_2, v_3)); + const uint64_t v_13 = canonicalize(word(v_4, v_5, v_6, v_7)); + if (v_12 > 0xffffffffULL || v_13 > 0xffffffffULL) return 3; + const uint32_t op_2 = uint32_t(v_12) - uint32_t(v_13); + const uint64_t v_14 = uint64_t(v_12 < v_13); + row[layout.auxiliaries + 1] = (v_12 & 0xffffULL); + row[layout.auxiliaries + 2] = ((v_12 >> 16) & 0xffffULL); + row[layout.auxiliaries + 3] = (uint64_t(op_2) & 0xffffULL); + row[layout.auxiliaries + 4] = ((uint64_t(op_2) >> 16) & 0xffffULL); + row[layout.auxiliaries + 5] = (v_13 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_13 >> 16) & 0xffffULL); + const WordSum op_3 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7)); + const uint64_t v_15 = ((op_3.low >> 0) & 255ULL); + const uint64_t v_16 = ((op_3.low >> 8) & 255ULL); + const uint64_t v_17 = ((op_3.low >> 16) & 255ULL); + const uint64_t v_18 = ((op_3.low >> 24) & 255ULL); + const uint64_t v_19 = op_3.carry; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + const WordSum op_4 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7), word(v_8, v_9, v_10, v_11)); + const uint64_t v_20 = ((op_4.low >> 0) & 255ULL); + const uint64_t v_21 = ((op_4.low >> 8) & 255ULL); + const uint64_t v_22 = ((op_4.low >> 16) & 255ULL); + const uint64_t v_23 = ((op_4.low >> 24) & 255ULL); + const uint64_t v_24 = op_4.carry; + row[layout.auxiliaries + 11] = v_20; + row[layout.auxiliaries + 12] = v_21; + row[layout.auxiliaries + 13] = v_22; + row[layout.auxiliaries + 14] = v_23; + const uint64_t v_25 = goldilocks_mul(v_19, v_24); + row[layout.auxiliaries + 15] = v_25; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_2(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 104; + const Seed_fixtures_2 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_2(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_2(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_2<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_2<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_2(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 12 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_2); +} + +__device__ __constant__ uint64_t inverse_3_1[] = {0ULL, 1ULL}; +__device__ __constant__ uint64_t inverse_3_2[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_fixtures_3 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_3(Seed_fixtures_3 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + uint64_t v_6; + switch (v_0) { + case 0ULL: { + const uint64_t v_2 = goldilocks_mul(v_1, v_1); + row[layout.auxiliaries + 1] = v_2; + row[layout.selectors + 0] = 1; + v_6 = v_2; + goto continuation_0; + } + case 1ULL: { + if (v_1 > 255 || v_1 > 255) return 1; + const uint64_t v_3 = ((v_1 + v_1) & 255ULL); + const uint64_t v_4 = ((v_1 + v_1) >> 8); + row[layout.auxiliaries + 1] = v_3; + row[layout.selectors + 1] = 1; + v_6 = v_3; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_3_1[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + row[layout.auxiliaries + 2] = (v_0 <= 1ULL ? inverse_3_2[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); + const uint64_t v_5 = uint64_t(v_1 == 0); + row[layout.auxiliaries + 3] = inverse(v_1); + row[layout.auxiliaries + 4] = v_5; + row[layout.selectors + 2] = 1; + v_6 = v_5; + goto continuation_0; + } + } + continuation_0:; + row[layout.auxiliaries + 5] = v_6; + const uint64_t v_7 = goldilocks_mul(v_6, v_1); + row[layout.auxiliaries + 6] = v_7; + row[layout.selectors + 3] = 1; + return 0; +} +template __global__ void kernel_fixtures_3(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_3 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_3(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_3(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_3<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_3<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_3(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_3); +} + +template struct Seed_fixtures_4 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 32); + case 3: return load_u32(data + 36); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_4(Seed_fixtures_4 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 2] = v_2; + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 3] = v_3; + const uint64_t v_4 = seed.word(4); + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_4(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 48; + const Seed_fixtures_4 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_4(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_4(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_4<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_4<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_4(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_4); +} + +template struct Seed_fixtures_5 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_5(Seed_fixtures_5 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_5(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 16; + const Seed_fixtures_5 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_5(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_5(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_5<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_5<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_5(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 16 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_5); +} + +template struct Seed_fixtures_6 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_6(Seed_fixtures_6 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 2] = v_2; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_6(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_6 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_6(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_6(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_6<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_6<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_6(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_6); +} + +template struct Seed_fixtures_7 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 40); + case 4: return load_u32(data + 44); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_7(Seed_fixtures_7 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_7(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 56; + const Seed_fixtures_7 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_7(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_7(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_7<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_7<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_7(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_7); +} + +__device__ __constant__ uint64_t inverse_8_1[] = {0ULL}; +template struct Seed_fixtures_8 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_8(Seed_fixtures_8 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_1 <= 0ULL ? inverse_8_1[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + row[layout.selectors + 1] = 1; + goto continuation_0; + } + } + continuation_0:; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 3] = v_2; + row[layout.selectors + 2] = 1; + return 0; +} +template __global__ void kernel_fixtures_8(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_8 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_8(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_8(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_8<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_8<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_8(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_8); +} + +__device__ __constant__ uint64_t inverse_9_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_9_2[] = {0ULL}; +template struct Seed_fixtures_9 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_9(Seed_fixtures_9 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + switch (v_0) { + case 0ULL: { + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_1 <= 0ULL ? inverse_9_1[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + row[layout.selectors + 1] = 1; + goto continuation_0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 0ULL ? inverse_9_2[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + row[layout.selectors + 2] = 1; + goto continuation_0; + } + } + continuation_0:; + const uint64_t v_2 = seed.word(2); + row[layout.auxiliaries + 3] = v_2; + row[layout.selectors + 3] = 1; + return 0; +} +template __global__ void kernel_fixtures_9(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_9 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_9(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_9(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_9<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_9<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_9(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_9); +} + +__device__ __constant__ uint64_t inverse_10_1[] = {0ULL}; +template struct Seed_fixtures_10 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u32(data + 40); + case 5: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_10(Seed_fixtures_10 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + uint64_t v_6; + switch (v_0) { + case 0ULL: { + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 1] = v_3; + row[layout.selectors + 0] = 1; + v_6 = v_3; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 0ULL ? inverse_10_1[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + const uint64_t v_4 = seed.word(3); + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.selectors + 1] = 1; + v_6 = v_5; + goto continuation_0; + } + } + continuation_0:; + row[layout.auxiliaries + 4] = v_6; + const uint64_t v_7 = seed.word(5); + row[layout.auxiliaries + 5] = v_7; + row[layout.selectors + 2] = 1; + return 0; +} +template __global__ void kernel_fixtures_10(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 48; + const Seed_fixtures_10 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_10(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_10(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_10<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_10<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_10(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_10); +} + +template struct Seed_fixtures_11 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 104); + case 4: return load_u32(data + 108); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + case 7: return load_u64(data + 40); + case 8: return load_u64(data + 48); + case 9: return load_u64(data + 56); + case 10: return load_u64(data + 64); + case 11: return load_u64(data + 72); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u64(data + 96); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_11(Seed_fixtures_11 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_11(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 112 : 120; + const Seed_fixtures_11 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_11(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_11(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_11<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_11<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_11(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 13) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 120 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_11); +} + +template struct Seed_fixtures_12 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_12(Seed_fixtures_12 seed, Layout layout, uint64_t* row) { + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_12(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 8 : 8; + const Seed_fixtures_12 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_12(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_12(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_12<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_12<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_12(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 0 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 8 : encoding == 0 ? 8 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_12); +} + +template struct Seed_fixtures_14 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_14(Seed_fixtures_14 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_14(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 24; + const Seed_fixtures_14 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_14(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_14(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_14<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_14<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_14(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 2) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 24 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_14); +} + +template struct Seed_fixtures_15 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_15(Seed_fixtures_15 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = goldilocks_mul(v_0, v_0); + row[layout.auxiliaries + 1] = v_1; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_15(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 16; + const Seed_fixtures_15 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_15(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_15(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_15<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_15<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_15(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 2) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 16 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_15); +} + +template struct Seed_fixtures_16 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_16(Seed_fixtures_16 seed, Layout layout, uint64_t* row) { + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_16(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 8 : 8; + const Seed_fixtures_16 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_16(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_16(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_16<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_16<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_16(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 0 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 8 : encoding == 0 ? 8 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_16); +} + +__device__ __constant__ uint64_t inverse_17_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_fixtures_17 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_17(Seed_fixtures_17 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_17_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_fixtures_17(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_fixtures_17 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_17(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_17(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_17<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_17<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_17(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_17); +} + +__device__ __constant__ uint64_t inverse_18_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_18_3[] = {0ULL}; +template struct Seed_fixtures_18 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_18(Seed_fixtures_18 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + uint64_t v_8; + switch (v_0) { + case 0ULL: { + uint64_t v_5; + switch (v_2) { + case 0ULL: { + const uint64_t v_3 = 0ULL; + row[layout.selectors + 0] = 1; + v_5 = v_3; + goto continuation_1; + } + default: { + row[layout.auxiliaries + 1] = (v_2 <= 0ULL ? inverse_18_2[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_4 = 1ULL; + row[layout.selectors + 1] = 1; + v_5 = v_4; + goto continuation_1; + } + } + continuation_1:; + row[layout.auxiliaries + 2] = v_5; + const uint64_t v_6 = goldilocks_add(v_5, v_2); + row[layout.selectors + 2] = 1; + v_8 = v_6; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 0ULL ? inverse_18_3[v_0] : inverse(goldilocks_sub(v_0, 0ULL))); + const uint64_t v_7 = 2ULL; + row[layout.selectors + 3] = 1; + v_8 = v_7; + goto continuation_0; + } + } + continuation_0:; + row[layout.auxiliaries + 3] = v_8; + const uint64_t v_9 = seed.word(4); + row[layout.auxiliaries + 4] = v_9; + row[layout.selectors + 4] = 1; + return 0; +} +template __global__ void kernel_fixtures_18(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 40; + const Seed_fixtures_18 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_18(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_18(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_18<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_18<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_18(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_18); +} + +template struct Seed_fixtures_19 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_19(Seed_fixtures_19 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + switch (v_0) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_fixtures_19(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 16; + const Seed_fixtures_19 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_19(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_19(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_19<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_19<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_19(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 1) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 16 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_19); +} + +template struct Seed_fixtures_20 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_20(Seed_fixtures_20 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const WordSum op_0 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7)); + const uint64_t v_12 = ((op_0.low >> 0) & 255ULL); + const uint64_t v_13 = ((op_0.low >> 8) & 255ULL); + const uint64_t v_14 = ((op_0.low >> 16) & 255ULL); + const uint64_t v_15 = ((op_0.low >> 24) & 255ULL); + const uint64_t v_16 = op_0.carry; + row[layout.auxiliaries + 1] = v_12; + row[layout.auxiliaries + 2] = v_13; + row[layout.auxiliaries + 3] = v_14; + row[layout.auxiliaries + 4] = v_15; + const WordSum op_1 = add_words(word(v_0, v_1, v_2, v_3), word(v_4, v_5, v_6, v_7), word(v_8, v_9, v_10, v_11)); + const uint64_t v_17 = ((op_1.low >> 0) & 255ULL); + const uint64_t v_18 = ((op_1.low >> 8) & 255ULL); + const uint64_t v_19 = ((op_1.low >> 16) & 255ULL); + const uint64_t v_20 = ((op_1.low >> 24) & 255ULL); + const uint64_t v_21 = op_1.carry; + row[layout.auxiliaries + 5] = v_17; + row[layout.auxiliaries + 6] = v_18; + row[layout.auxiliaries + 7] = v_19; + row[layout.auxiliaries + 8] = v_20; + const uint64_t v_22 = goldilocks_mul(v_16, v_21); + row[layout.auxiliaries + 9] = v_22; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_20(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 104; + const Seed_fixtures_20 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_20(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_20(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_20<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_20<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_20(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 12 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 10) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_20); +} + +template struct Seed_fixtures_21 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u64(data + 64); + case 9: return load_u64(data + 72); + case 10: return load_u64(data + 80); + case 11: return load_u64(data + 88); + case 12: return load_u64(data + 96); + case 13: return load_u64(data + 104); + case 14: return load_u64(data + 112); + case 15: return load_u64(data + 120); + case 16: return load_u64(data + 128); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_fixtures_21(Seed_fixtures_21 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = 256ULL; + const uint64_t v_17 = goldilocks_mul(v_16, v_1); + const uint64_t v_18 = goldilocks_add(v_0, v_17); + const uint64_t v_19 = goldilocks_mul(v_16, v_9); + const uint64_t v_20 = goldilocks_add(v_8, v_19); + const uint64_t v_21 = goldilocks_mul(v_16, v_3); + const uint64_t v_22 = goldilocks_add(v_2, v_21); + const uint64_t v_23 = goldilocks_mul(v_16, v_11); + const uint64_t v_24 = goldilocks_add(v_10, v_23); + const uint64_t v_25 = goldilocks_mul(v_16, v_5); + const uint64_t v_26 = goldilocks_add(v_4, v_25); + const uint64_t v_27 = goldilocks_mul(v_16, v_13); + const uint64_t v_28 = goldilocks_add(v_12, v_27); + const uint64_t v_29 = goldilocks_mul(v_16, v_7); + const uint64_t v_30 = goldilocks_add(v_6, v_29); + const uint64_t v_31 = goldilocks_mul(v_16, v_15); + const uint64_t v_32 = goldilocks_add(v_14, v_31); + const uint64_t v_33 = goldilocks_mul(v_18, v_20); + row[layout.auxiliaries + 1] = v_33; + const uint64_t v_34 = ((v_33 >> 0) & 255ULL); + const uint64_t v_35 = ((v_33 >> 8) & 255ULL); + const uint64_t v_36 = ((v_33 >> 16) & 255ULL); + const uint64_t v_37 = ((v_33 >> 24) & 255ULL); + const uint64_t v_38 = ((v_33 >> 32) & 255ULL); + const uint64_t v_39 = ((v_33 >> 40) & 255ULL); + const uint64_t v_40 = ((v_33 >> 48) & 255ULL); + const uint64_t v_41 = ((v_33 >> 56) & 255ULL); + row[layout.auxiliaries + 2] = v_34; + row[layout.auxiliaries + 3] = v_35; + row[layout.auxiliaries + 4] = v_36; + row[layout.auxiliaries + 5] = v_37; + row[layout.auxiliaries + 6] = v_38; + row[layout.auxiliaries + 7] = v_39; + row[layout.auxiliaries + 8] = v_40; + row[layout.auxiliaries + 9] = v_41; + const uint64_t v_44 = 65536ULL; + const uint64_t v_45 = goldilocks_mul(v_16, v_37); + const uint64_t v_46 = goldilocks_mul(v_44, v_38); + const uint64_t v_47 = goldilocks_add(v_45, v_46); + const uint64_t v_48 = goldilocks_add(v_36, v_47); + const uint64_t v_52 = goldilocks_mul(v_18, v_24); + row[layout.auxiliaries + 10] = v_52; + const uint64_t v_53 = goldilocks_mul(v_22, v_20); + row[layout.auxiliaries + 11] = v_53; + const uint64_t v_54 = goldilocks_add(v_53, v_48); + const uint64_t v_55 = goldilocks_add(v_52, v_54); + const uint64_t v_56 = ((v_55 >> 0) & 255ULL); + const uint64_t v_57 = ((v_55 >> 8) & 255ULL); + const uint64_t v_58 = ((v_55 >> 16) & 255ULL); + const uint64_t v_59 = ((v_55 >> 24) & 255ULL); + const uint64_t v_60 = ((v_55 >> 32) & 255ULL); + const uint64_t v_61 = ((v_55 >> 40) & 255ULL); + const uint64_t v_62 = ((v_55 >> 48) & 255ULL); + const uint64_t v_63 = ((v_55 >> 56) & 255ULL); + row[layout.auxiliaries + 12] = v_56; + row[layout.auxiliaries + 13] = v_57; + row[layout.auxiliaries + 14] = v_58; + row[layout.auxiliaries + 15] = v_59; + row[layout.auxiliaries + 16] = v_60; + row[layout.auxiliaries + 17] = v_61; + row[layout.auxiliaries + 18] = v_62; + row[layout.auxiliaries + 19] = v_63; + const uint64_t v_65 = goldilocks_mul(v_16, v_59); + const uint64_t v_66 = goldilocks_mul(v_44, v_60); + const uint64_t v_67 = goldilocks_add(v_65, v_66); + const uint64_t v_68 = goldilocks_add(v_58, v_67); + const uint64_t v_72 = goldilocks_mul(v_18, v_28); + row[layout.auxiliaries + 20] = v_72; + const uint64_t v_73 = goldilocks_mul(v_22, v_24); + row[layout.auxiliaries + 21] = v_73; + const uint64_t v_74 = goldilocks_mul(v_26, v_20); + row[layout.auxiliaries + 22] = v_74; + const uint64_t v_75 = goldilocks_add(v_74, v_68); + const uint64_t v_76 = goldilocks_add(v_73, v_75); + const uint64_t v_77 = goldilocks_add(v_72, v_76); + const uint64_t v_78 = ((v_77 >> 0) & 255ULL); + const uint64_t v_79 = ((v_77 >> 8) & 255ULL); + const uint64_t v_80 = ((v_77 >> 16) & 255ULL); + const uint64_t v_81 = ((v_77 >> 24) & 255ULL); + const uint64_t v_82 = ((v_77 >> 32) & 255ULL); + const uint64_t v_83 = ((v_77 >> 40) & 255ULL); + const uint64_t v_84 = ((v_77 >> 48) & 255ULL); + const uint64_t v_85 = ((v_77 >> 56) & 255ULL); + row[layout.auxiliaries + 23] = v_78; + row[layout.auxiliaries + 24] = v_79; + row[layout.auxiliaries + 25] = v_80; + row[layout.auxiliaries + 26] = v_81; + row[layout.auxiliaries + 27] = v_82; + row[layout.auxiliaries + 28] = v_83; + row[layout.auxiliaries + 29] = v_84; + row[layout.auxiliaries + 30] = v_85; + const uint64_t v_87 = goldilocks_mul(v_16, v_81); + const uint64_t v_88 = goldilocks_mul(v_44, v_82); + const uint64_t v_89 = goldilocks_add(v_87, v_88); + const uint64_t v_90 = goldilocks_add(v_80, v_89); + const uint64_t v_94 = goldilocks_mul(v_18, v_32); + row[layout.auxiliaries + 31] = v_94; + const uint64_t v_95 = goldilocks_mul(v_22, v_28); + row[layout.auxiliaries + 32] = v_95; + const uint64_t v_96 = goldilocks_mul(v_26, v_24); + row[layout.auxiliaries + 33] = v_96; + const uint64_t v_97 = goldilocks_mul(v_30, v_20); + row[layout.auxiliaries + 34] = v_97; + const uint64_t v_98 = goldilocks_add(v_97, v_90); + const uint64_t v_99 = goldilocks_add(v_96, v_98); + const uint64_t v_100 = goldilocks_add(v_95, v_99); + const uint64_t v_101 = goldilocks_add(v_94, v_100); + const uint64_t v_102 = ((v_101 >> 0) & 255ULL); + const uint64_t v_103 = ((v_101 >> 8) & 255ULL); + const uint64_t v_104 = ((v_101 >> 16) & 255ULL); + const uint64_t v_105 = ((v_101 >> 24) & 255ULL); + const uint64_t v_106 = ((v_101 >> 32) & 255ULL); + const uint64_t v_107 = ((v_101 >> 40) & 255ULL); + const uint64_t v_108 = ((v_101 >> 48) & 255ULL); + const uint64_t v_109 = ((v_101 >> 56) & 255ULL); + row[layout.auxiliaries + 35] = v_102; + row[layout.auxiliaries + 36] = v_103; + row[layout.auxiliaries + 37] = v_104; + row[layout.auxiliaries + 38] = v_105; + row[layout.auxiliaries + 39] = v_106; + row[layout.auxiliaries + 40] = v_107; + row[layout.auxiliaries + 41] = v_108; + row[layout.auxiliaries + 42] = v_109; + const uint64_t v_111 = goldilocks_mul(v_16, v_105); + const uint64_t v_112 = goldilocks_mul(v_44, v_106); + const uint64_t v_113 = goldilocks_add(v_111, v_112); + const uint64_t v_114 = goldilocks_add(v_104, v_113); + const uint64_t v_118 = goldilocks_mul(v_22, v_32); + row[layout.auxiliaries + 43] = v_118; + const uint64_t v_119 = goldilocks_mul(v_26, v_28); + row[layout.auxiliaries + 44] = v_119; + const uint64_t v_120 = goldilocks_mul(v_30, v_24); + row[layout.auxiliaries + 45] = v_120; + const uint64_t v_121 = goldilocks_add(v_120, v_114); + const uint64_t v_122 = goldilocks_add(v_119, v_121); + const uint64_t v_123 = goldilocks_add(v_118, v_122); + const uint64_t v_124 = ((v_123 >> 0) & 255ULL); + const uint64_t v_125 = ((v_123 >> 8) & 255ULL); + const uint64_t v_126 = ((v_123 >> 16) & 255ULL); + const uint64_t v_127 = ((v_123 >> 24) & 255ULL); + const uint64_t v_128 = ((v_123 >> 32) & 255ULL); + const uint64_t v_129 = ((v_123 >> 40) & 255ULL); + const uint64_t v_130 = ((v_123 >> 48) & 255ULL); + const uint64_t v_131 = ((v_123 >> 56) & 255ULL); + row[layout.auxiliaries + 46] = v_124; + row[layout.auxiliaries + 47] = v_125; + row[layout.auxiliaries + 48] = v_126; + row[layout.auxiliaries + 49] = v_127; + row[layout.auxiliaries + 50] = v_128; + row[layout.auxiliaries + 51] = v_129; + row[layout.auxiliaries + 52] = v_130; + row[layout.auxiliaries + 53] = v_131; + const uint64_t v_133 = goldilocks_mul(v_16, v_127); + const uint64_t v_134 = goldilocks_mul(v_44, v_128); + const uint64_t v_135 = goldilocks_add(v_133, v_134); + const uint64_t v_136 = goldilocks_add(v_126, v_135); + const uint64_t v_140 = goldilocks_mul(v_26, v_32); + row[layout.auxiliaries + 54] = v_140; + const uint64_t v_141 = goldilocks_mul(v_30, v_28); + row[layout.auxiliaries + 55] = v_141; + const uint64_t v_142 = goldilocks_add(v_141, v_136); + const uint64_t v_143 = goldilocks_add(v_140, v_142); + const uint64_t v_144 = ((v_143 >> 0) & 255ULL); + const uint64_t v_145 = ((v_143 >> 8) & 255ULL); + const uint64_t v_146 = ((v_143 >> 16) & 255ULL); + const uint64_t v_147 = ((v_143 >> 24) & 255ULL); + const uint64_t v_148 = ((v_143 >> 32) & 255ULL); + const uint64_t v_149 = ((v_143 >> 40) & 255ULL); + const uint64_t v_150 = ((v_143 >> 48) & 255ULL); + const uint64_t v_151 = ((v_143 >> 56) & 255ULL); + row[layout.auxiliaries + 56] = v_144; + row[layout.auxiliaries + 57] = v_145; + row[layout.auxiliaries + 58] = v_146; + row[layout.auxiliaries + 59] = v_147; + row[layout.auxiliaries + 60] = v_148; + row[layout.auxiliaries + 61] = v_149; + row[layout.auxiliaries + 62] = v_150; + row[layout.auxiliaries + 63] = v_151; + const uint64_t v_153 = goldilocks_mul(v_16, v_147); + const uint64_t v_154 = goldilocks_mul(v_44, v_148); + const uint64_t v_155 = goldilocks_add(v_153, v_154); + const uint64_t v_156 = goldilocks_add(v_146, v_155); + const uint64_t v_160 = goldilocks_mul(v_30, v_32); + row[layout.auxiliaries + 64] = v_160; + const uint64_t v_161 = goldilocks_add(v_160, v_156); + const uint64_t v_162 = ((v_161 >> 0) & 255ULL); + const uint64_t v_163 = ((v_161 >> 8) & 255ULL); + const uint64_t v_164 = ((v_161 >> 16) & 255ULL); + const uint64_t v_165 = ((v_161 >> 24) & 255ULL); + const uint64_t v_166 = ((v_161 >> 32) & 255ULL); + const uint64_t v_167 = ((v_161 >> 40) & 255ULL); + const uint64_t v_168 = ((v_161 >> 48) & 255ULL); + const uint64_t v_169 = ((v_161 >> 56) & 255ULL); + row[layout.auxiliaries + 65] = v_162; + row[layout.auxiliaries + 66] = v_163; + row[layout.auxiliaries + 67] = v_164; + row[layout.auxiliaries + 68] = v_165; + row[layout.auxiliaries + 69] = v_166; + row[layout.auxiliaries + 70] = v_167; + row[layout.auxiliaries + 71] = v_168; + row[layout.auxiliaries + 72] = v_169; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_fixtures_21(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 136 : 136; + const Seed_fixtures_21 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_fixtures_21(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_fixtures_21(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_fixtures_21<<>>(seeds, real, rows, layout, output, error); + else kernel_fixtures_21<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_fixtures_21(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 73) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 136 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_fixtures_21); +} + +extern "C" const uint8_t* aiur_trace_fixtures_contract() { + static const uint8_t hash[32] = {213, 235, 108, 220, 115, 159, 51, 229, 206, 4, 193, 234, 222, 143, 95, 162, 130, 93, 210, 36, 144, 208, 151, 97, 95, 24, 25, 23, 225, 30, 236, 67}; + return hash; +} +extern "C" const uint8_t* aiur_trace_fixtures_schema() { + static const uint8_t hash[32] = {37, 185, 21, 81, 113, 228, 73, 167, 217, 138, 89, 160, 206, 9, 127, 220, 167, 73, 73, 205, 226, 204, 26, 55, 228, 3, 11, 111, 3, 154, 149, 82}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/ix_aggr.cu b/crates/aiur/cuda/generated/production/ix_aggr.cu new file mode 100644 index 000000000..c0573b8f4 --- /dev/null +++ b/crates/aiur/cuda/generated/production/ix_aggr.cu @@ -0,0 +1,2801 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_ix_aggr { +using namespace aiur_trace; + +__device__ __constant__ uint64_t inverse_86_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ix_aggr_86 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_86(Seed_ix_aggr_86 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_86_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ix_aggr_86(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_ix_aggr_86 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_86(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_86(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_86<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_86<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_86(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_86); +} + +__device__ __constant__ uint64_t inverse_117_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_3[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_4[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_5[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_6[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_7[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_8[] = {0ULL}; +__device__ __constant__ uint64_t inverse_117_10[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_117_11[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_117_12[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_117_13[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ix_aggr_117 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 312); + case 2: return load_u32(data + 316); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 320); + case 5: return load_u32(data + 324); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 404); + case 8: return load_u8(data + 405); + case 9: return load_u8(data + 406); + case 10: return load_u8(data + 407); + case 11: return load_u8(data + 408); + case 12: return load_u8(data + 409); + case 13: return load_u8(data + 410); + case 14: return load_u8(data + 411); + case 15: return load_u32(data + 328); + case 16: return load_u32(data + 332); + case 17: return load_u8(data + 412); + case 18: return load_u64(data + 24); + case 19: return load_u64(data + 32); + case 20: return load_u64(data + 40); + case 21: return load_u64(data + 48); + case 22: return load_u64(data + 56); + case 23: return load_u64(data + 64); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u32(data + 336); + case 27: return load_u32(data + 340); + case 28: return load_u8(data + 413); + case 29: return load_u8(data + 414); + case 30: return load_u8(data + 415); + case 31: return load_u8(data + 416); + case 32: return load_u8(data + 417); + case 33: return load_u8(data + 418); + case 34: return load_u8(data + 419); + case 35: return load_u8(data + 420); + case 36: return load_u8(data + 421); + case 37: return load_u32(data + 344); + case 38: return load_u32(data + 348); + case 39: return load_u8(data + 422); + case 40: return load_u8(data + 423); + case 41: return load_u8(data + 424); + case 42: return load_u8(data + 425); + case 43: return load_u8(data + 426); + case 44: return load_u8(data + 427); + case 45: return load_u8(data + 428); + case 46: return load_u8(data + 429); + case 47: return load_u8(data + 430); + case 48: return load_u32(data + 352); + case 49: return load_u32(data + 356); + case 50: return load_u8(data + 431); + case 51: return load_u8(data + 432); + case 52: return load_u8(data + 433); + case 53: return load_u8(data + 434); + case 54: return load_u8(data + 435); + case 55: return load_u8(data + 436); + case 56: return load_u8(data + 437); + case 57: return load_u8(data + 438); + case 58: return load_u8(data + 439); + case 59: return load_u32(data + 360); + case 60: return load_u32(data + 364); + case 61: return load_u8(data + 440); + case 62: return load_u8(data + 441); + case 63: return load_u8(data + 442); + case 64: return load_u8(data + 443); + case 65: return load_u8(data + 444); + case 66: return load_u8(data + 445); + case 67: return load_u8(data + 446); + case 68: return load_u8(data + 447); + case 69: return load_u8(data + 448); + case 70: return load_u32(data + 368); + case 71: return load_u32(data + 372); + case 72: return load_u8(data + 449); + case 73: return load_u8(data + 450); + case 74: return load_u8(data + 451); + case 75: return load_u8(data + 452); + case 76: return load_u8(data + 453); + case 77: return load_u8(data + 454); + case 78: return load_u8(data + 455); + case 79: return load_u8(data + 456); + case 80: return load_u8(data + 457); + case 81: return load_u32(data + 376); + case 82: return load_u32(data + 380); + case 83: return load_u8(data + 458); + case 84: return load_u8(data + 459); + case 85: return load_u8(data + 460); + case 86: return load_u8(data + 461); + case 87: return load_u8(data + 462); + case 88: return load_u8(data + 463); + case 89: return load_u8(data + 464); + case 90: return load_u8(data + 465); + case 91: return load_u8(data + 466); + case 92: return load_u32(data + 384); + case 93: return load_u32(data + 388); + case 94: return load_u8(data + 467); + case 95: return load_u8(data + 468); + case 96: return load_u64(data + 88); + case 97: return load_u64(data + 96); + case 98: return load_u64(data + 104); + case 99: return load_u64(data + 112); + case 100: return load_u64(data + 120); + case 101: return load_u64(data + 128); + case 102: return load_u64(data + 136); + case 103: return load_u64(data + 144); + case 104: return load_u64(data + 152); + case 105: return load_u8(data + 469); + case 106: return load_u64(data + 160); + case 107: return load_u64(data + 168); + case 108: return load_u8(data + 470); + case 109: return load_u8(data + 471); + case 110: return load_u8(data + 472); + case 111: return load_u8(data + 473); + case 112: return load_u8(data + 474); + case 113: return load_u8(data + 475); + case 114: return load_u8(data + 476); + case 115: return load_u8(data + 477); + case 116: return load_u8(data + 478); + case 117: return load_u8(data + 479); + case 118: return load_u8(data + 480); + case 119: return load_u8(data + 481); + case 120: return load_u8(data + 482); + case 121: return load_u8(data + 483); + case 122: return load_u8(data + 484); + case 123: return load_u8(data + 485); + case 124: return load_u8(data + 486); + case 125: return load_u8(data + 487); + case 126: return load_u8(data + 488); + case 127: return load_u8(data + 489); + case 128: return load_u8(data + 490); + case 129: return load_u8(data + 491); + case 130: return load_u8(data + 492); + case 131: return load_u8(data + 493); + case 132: return load_u8(data + 494); + case 133: return load_u8(data + 495); + case 134: return load_u8(data + 496); + case 135: return load_u8(data + 497); + case 136: return load_u8(data + 498); + case 137: return load_u8(data + 499); + case 138: return load_u8(data + 500); + case 139: return load_u8(data + 501); + case 140: return load_u8(data + 502); + case 141: return load_u8(data + 503); + case 142: return load_u8(data + 504); + case 143: return load_u8(data + 505); + case 144: return load_u8(data + 506); + case 145: return load_u8(data + 507); + case 146: return load_u8(data + 508); + case 147: return load_u8(data + 509); + case 148: return load_u8(data + 510); + case 149: return load_u8(data + 511); + case 150: return load_u8(data + 512); + case 151: return load_u8(data + 513); + case 152: return load_u8(data + 514); + case 153: return load_u8(data + 515); + case 154: return load_u8(data + 516); + case 155: return load_u8(data + 517); + case 156: return load_u8(data + 518); + case 157: return load_u8(data + 519); + case 158: return load_u8(data + 520); + case 159: return load_u8(data + 521); + case 160: return load_u8(data + 522); + case 161: return load_u8(data + 523); + case 162: return load_u8(data + 524); + case 163: return load_u8(data + 525); + case 164: return load_u8(data + 526); + case 165: return load_u8(data + 527); + case 166: return load_u8(data + 528); + case 167: return load_u8(data + 529); + case 168: return load_u8(data + 530); + case 169: return load_u8(data + 531); + case 170: return load_u8(data + 532); + case 171: return load_u8(data + 533); + case 172: return load_u8(data + 534); + case 173: return load_u8(data + 535); + case 174: return load_u8(data + 536); + case 175: return load_u8(data + 537); + case 176: return load_u8(data + 538); + case 177: return load_u8(data + 539); + case 178: return load_u8(data + 540); + case 179: return load_u8(data + 541); + case 180: return load_u8(data + 542); + case 181: return load_u64(data + 176); + case 182: return load_u64(data + 184); + case 183: return load_u64(data + 192); + case 184: return load_u64(data + 200); + case 185: return load_u64(data + 208); + case 186: return load_u64(data + 216); + case 187: return load_u64(data + 224); + case 188: return load_u64(data + 232); + case 189: return load_u64(data + 240); + case 190: return load_u64(data + 248); + case 191: return load_u64(data + 256); + case 192: return load_u64(data + 264); + case 193: return load_u64(data + 272); + case 194: return load_u64(data + 280); + case 195: return load_u64(data + 288); + case 196: return load_u64(data + 296); + case 197: return load_u32(data + 392); + case 198: return load_u32(data + 396); + case 199: return load_u32(data + 400); + case 200: return load_u64(data + 304); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_117(Seed_ix_aggr_117 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + row[layout.auxiliaries + 1] = v_6; + row[layout.auxiliaries + 2] = v_7; + row[layout.auxiliaries + 3] = v_8; + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.auxiliaries + 7] = v_12; + row[layout.auxiliaries + 8] = v_13; + row[layout.auxiliaries + 9] = v_14; + row[layout.auxiliaries + 10] = v_15; + row[layout.auxiliaries + 11] = v_16; + switch (v_16) { + case 0ULL: { + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.auxiliaries + 14] = v_19; + row[layout.auxiliaries + 15] = v_20; + row[layout.auxiliaries + 16] = v_21; + row[layout.auxiliaries + 17] = v_22; + row[layout.auxiliaries + 18] = v_23; + row[layout.auxiliaries + 19] = v_24; + switch (v_17) { + case 0ULL: { + switch (v_18) { + case 0ULL: { + switch (v_19) { + case 0ULL: { + switch (v_20) { + case 0ULL: { + switch (v_21) { + case 0ULL: { + switch (v_22) { + case 0ULL: { + switch (v_23) { + case 0ULL: { + switch (v_24) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + row[layout.auxiliaries + 22] = v_27; + row[layout.auxiliaries + 23] = v_28; + row[layout.auxiliaries + 24] = v_29; + row[layout.auxiliaries + 25] = v_30; + row[layout.auxiliaries + 26] = v_31; + row[layout.auxiliaries + 27] = v_32; + row[layout.auxiliaries + 28] = v_33; + row[layout.auxiliaries + 29] = v_34; + row[layout.auxiliaries + 30] = v_35; + row[layout.auxiliaries + 31] = v_36; + row[layout.auxiliaries + 32] = v_37; + row[layout.auxiliaries + 33] = v_38; + row[layout.auxiliaries + 34] = v_39; + row[layout.auxiliaries + 35] = v_40; + row[layout.auxiliaries + 36] = v_41; + row[layout.auxiliaries + 37] = v_42; + row[layout.auxiliaries + 38] = v_43; + row[layout.auxiliaries + 39] = v_44; + row[layout.auxiliaries + 40] = v_45; + row[layout.auxiliaries + 41] = v_46; + row[layout.auxiliaries + 42] = v_47; + row[layout.auxiliaries + 43] = v_48; + row[layout.auxiliaries + 44] = v_49; + row[layout.auxiliaries + 45] = v_50; + row[layout.auxiliaries + 46] = v_51; + row[layout.auxiliaries + 47] = v_52; + row[layout.auxiliaries + 48] = v_53; + row[layout.auxiliaries + 49] = v_54; + row[layout.auxiliaries + 50] = v_55; + row[layout.auxiliaries + 51] = v_56; + const uint64_t v_58 = seed.word(58); + const uint64_t v_59 = seed.word(59); + const uint64_t v_60 = seed.word(60); + const uint64_t v_61 = seed.word(61); + const uint64_t v_62 = seed.word(62); + const uint64_t v_63 = seed.word(63); + const uint64_t v_64 = seed.word(64); + const uint64_t v_65 = seed.word(65); + row[layout.auxiliaries + 52] = v_58; + row[layout.auxiliaries + 53] = v_59; + row[layout.auxiliaries + 54] = v_60; + row[layout.auxiliaries + 55] = v_61; + row[layout.auxiliaries + 56] = v_62; + row[layout.auxiliaries + 57] = v_63; + row[layout.auxiliaries + 58] = v_64; + row[layout.auxiliaries + 59] = v_65; + const uint64_t v_82 = seed.word(66); + const uint64_t v_83 = seed.word(67); + const uint64_t v_84 = seed.word(68); + const uint64_t v_85 = seed.word(69); + const uint64_t v_86 = seed.word(70); + const uint64_t v_87 = seed.word(71); + const uint64_t v_88 = seed.word(72); + const uint64_t v_89 = seed.word(73); + const uint64_t v_90 = seed.word(74); + const uint64_t v_91 = seed.word(75); + const uint64_t v_92 = seed.word(76); + const uint64_t v_93 = seed.word(77); + const uint64_t v_94 = seed.word(78); + const uint64_t v_95 = seed.word(79); + const uint64_t v_96 = seed.word(80); + const uint64_t v_97 = seed.word(81); + const uint64_t v_98 = seed.word(82); + const uint64_t v_99 = seed.word(83); + const uint64_t v_100 = seed.word(84); + const uint64_t v_101 = seed.word(85); + const uint64_t v_102 = seed.word(86); + const uint64_t v_103 = seed.word(87); + const uint64_t v_104 = seed.word(88); + const uint64_t v_105 = seed.word(89); + const uint64_t v_106 = seed.word(90); + const uint64_t v_107 = seed.word(91); + const uint64_t v_108 = seed.word(92); + const uint64_t v_109 = seed.word(93); + const uint64_t v_110 = seed.word(94); + const uint64_t v_111 = seed.word(95); + const uint64_t v_112 = seed.word(96); + const uint64_t v_113 = seed.word(97); + row[layout.auxiliaries + 60] = v_82; + row[layout.auxiliaries + 61] = v_83; + row[layout.auxiliaries + 62] = v_84; + row[layout.auxiliaries + 63] = v_85; + row[layout.auxiliaries + 64] = v_86; + row[layout.auxiliaries + 65] = v_87; + row[layout.auxiliaries + 66] = v_88; + row[layout.auxiliaries + 67] = v_89; + row[layout.auxiliaries + 68] = v_90; + row[layout.auxiliaries + 69] = v_91; + row[layout.auxiliaries + 70] = v_92; + row[layout.auxiliaries + 71] = v_93; + row[layout.auxiliaries + 72] = v_94; + row[layout.auxiliaries + 73] = v_95; + row[layout.auxiliaries + 74] = v_96; + row[layout.auxiliaries + 75] = v_97; + row[layout.auxiliaries + 76] = v_98; + row[layout.auxiliaries + 77] = v_99; + row[layout.auxiliaries + 78] = v_100; + row[layout.auxiliaries + 79] = v_101; + row[layout.auxiliaries + 80] = v_102; + row[layout.auxiliaries + 81] = v_103; + row[layout.auxiliaries + 82] = v_104; + row[layout.auxiliaries + 83] = v_105; + row[layout.auxiliaries + 84] = v_106; + row[layout.auxiliaries + 85] = v_107; + row[layout.auxiliaries + 86] = v_108; + row[layout.auxiliaries + 87] = v_109; + row[layout.auxiliaries + 88] = v_110; + row[layout.auxiliaries + 89] = v_111; + row[layout.auxiliaries + 90] = v_112; + row[layout.auxiliaries + 91] = v_113; + const uint64_t v_114 = seed.word(98); + row[layout.auxiliaries + 92] = v_114; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 20] = (v_24 <= 0ULL ? inverse_117_0[v_24] : inverse(goldilocks_sub(v_24, 0ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_23 <= 0ULL ? inverse_117_1[v_23] : inverse(goldilocks_sub(v_23, 0ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_22 <= 0ULL ? inverse_117_2[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_21 <= 0ULL ? inverse_117_3[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_20 <= 0ULL ? inverse_117_4[v_20] : inverse(goldilocks_sub(v_20, 0ULL))); + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_19 <= 0ULL ? inverse_117_5[v_19] : inverse(goldilocks_sub(v_19, 0ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_18 <= 0ULL ? inverse_117_6[v_18] : inverse(goldilocks_sub(v_18, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_17 <= 0ULL ? inverse_117_7[v_17] : inverse(goldilocks_sub(v_17, 0ULL))); + row[layout.selectors + 8] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 12] = (v_16 <= 0ULL ? inverse_117_8[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); + const uint64_t v_115 = seed.word(18); + const uint64_t v_116 = seed.word(19); + const uint64_t v_117 = seed.word(20); + const uint64_t v_118 = seed.word(21); + const uint64_t v_119 = seed.word(22); + const uint64_t v_120 = seed.word(23); + const uint64_t v_121 = seed.word(24); + const uint64_t v_122 = seed.word(25); + const uint64_t v_123 = seed.word(26); + const uint64_t v_124 = seed.word(27); + const uint64_t v_125 = seed.word(28); + row[layout.auxiliaries + 13] = v_115; + row[layout.auxiliaries + 14] = v_116; + row[layout.auxiliaries + 15] = v_117; + row[layout.auxiliaries + 16] = v_118; + row[layout.auxiliaries + 17] = v_119; + row[layout.auxiliaries + 18] = v_120; + row[layout.auxiliaries + 19] = v_121; + row[layout.auxiliaries + 20] = v_122; + row[layout.auxiliaries + 21] = v_123; + row[layout.auxiliaries + 22] = v_124; + row[layout.auxiliaries + 23] = v_125; + const uint64_t v_126 = seed.word(29); + const uint64_t v_127 = seed.word(30); + const uint64_t v_128 = seed.word(31); + const uint64_t v_129 = seed.word(32); + const uint64_t v_130 = seed.word(33); + const uint64_t v_131 = seed.word(34); + const uint64_t v_132 = seed.word(35); + const uint64_t v_133 = seed.word(36); + const uint64_t v_134 = seed.word(37); + const uint64_t v_135 = seed.word(38); + const uint64_t v_136 = seed.word(39); + row[layout.auxiliaries + 24] = v_126; + row[layout.auxiliaries + 25] = v_127; + row[layout.auxiliaries + 26] = v_128; + row[layout.auxiliaries + 27] = v_129; + row[layout.auxiliaries + 28] = v_130; + row[layout.auxiliaries + 29] = v_131; + row[layout.auxiliaries + 30] = v_132; + row[layout.auxiliaries + 31] = v_133; + row[layout.auxiliaries + 32] = v_134; + row[layout.auxiliaries + 33] = v_135; + row[layout.auxiliaries + 34] = v_136; + const uint64_t v_137 = seed.word(40); + const uint64_t v_138 = seed.word(41); + const uint64_t v_139 = seed.word(42); + const uint64_t v_140 = seed.word(43); + const uint64_t v_141 = seed.word(44); + const uint64_t v_142 = seed.word(45); + const uint64_t v_143 = seed.word(46); + const uint64_t v_144 = seed.word(47); + const uint64_t v_145 = seed.word(48); + const uint64_t v_146 = seed.word(49); + const uint64_t v_147 = seed.word(50); + row[layout.auxiliaries + 35] = v_137; + row[layout.auxiliaries + 36] = v_138; + row[layout.auxiliaries + 37] = v_139; + row[layout.auxiliaries + 38] = v_140; + row[layout.auxiliaries + 39] = v_141; + row[layout.auxiliaries + 40] = v_142; + row[layout.auxiliaries + 41] = v_143; + row[layout.auxiliaries + 42] = v_144; + row[layout.auxiliaries + 43] = v_145; + row[layout.auxiliaries + 44] = v_146; + row[layout.auxiliaries + 45] = v_147; + const uint64_t v_148 = seed.word(51); + const uint64_t v_149 = seed.word(52); + const uint64_t v_150 = seed.word(53); + const uint64_t v_151 = seed.word(54); + const uint64_t v_152 = seed.word(55); + const uint64_t v_153 = seed.word(56); + const uint64_t v_154 = seed.word(57); + const uint64_t v_155 = seed.word(58); + const uint64_t v_156 = seed.word(59); + const uint64_t v_157 = seed.word(60); + const uint64_t v_158 = seed.word(61); + row[layout.auxiliaries + 46] = v_148; + row[layout.auxiliaries + 47] = v_149; + row[layout.auxiliaries + 48] = v_150; + row[layout.auxiliaries + 49] = v_151; + row[layout.auxiliaries + 50] = v_152; + row[layout.auxiliaries + 51] = v_153; + row[layout.auxiliaries + 52] = v_154; + row[layout.auxiliaries + 53] = v_155; + row[layout.auxiliaries + 54] = v_156; + row[layout.auxiliaries + 55] = v_157; + row[layout.auxiliaries + 56] = v_158; + const uint64_t v_159 = seed.word(62); + const uint64_t v_160 = seed.word(63); + const uint64_t v_161 = seed.word(64); + const uint64_t v_162 = seed.word(65); + const uint64_t v_163 = seed.word(66); + const uint64_t v_164 = seed.word(67); + const uint64_t v_165 = seed.word(68); + const uint64_t v_166 = seed.word(69); + const uint64_t v_167 = seed.word(70); + const uint64_t v_168 = seed.word(71); + const uint64_t v_169 = seed.word(72); + row[layout.auxiliaries + 57] = v_159; + row[layout.auxiliaries + 58] = v_160; + row[layout.auxiliaries + 59] = v_161; + row[layout.auxiliaries + 60] = v_162; + row[layout.auxiliaries + 61] = v_163; + row[layout.auxiliaries + 62] = v_164; + row[layout.auxiliaries + 63] = v_165; + row[layout.auxiliaries + 64] = v_166; + row[layout.auxiliaries + 65] = v_167; + row[layout.auxiliaries + 66] = v_168; + row[layout.auxiliaries + 67] = v_169; + const uint64_t v_170 = seed.word(73); + const uint64_t v_171 = seed.word(74); + const uint64_t v_172 = seed.word(75); + const uint64_t v_173 = seed.word(76); + const uint64_t v_174 = seed.word(77); + const uint64_t v_175 = seed.word(78); + const uint64_t v_176 = seed.word(79); + const uint64_t v_177 = seed.word(80); + const uint64_t v_178 = seed.word(81); + const uint64_t v_179 = seed.word(82); + const uint64_t v_180 = seed.word(83); + row[layout.auxiliaries + 68] = v_170; + row[layout.auxiliaries + 69] = v_171; + row[layout.auxiliaries + 70] = v_172; + row[layout.auxiliaries + 71] = v_173; + row[layout.auxiliaries + 72] = v_174; + row[layout.auxiliaries + 73] = v_175; + row[layout.auxiliaries + 74] = v_176; + row[layout.auxiliaries + 75] = v_177; + row[layout.auxiliaries + 76] = v_178; + row[layout.auxiliaries + 77] = v_179; + row[layout.auxiliaries + 78] = v_180; + const uint64_t v_181 = seed.word(84); + const uint64_t v_182 = seed.word(85); + const uint64_t v_183 = seed.word(86); + const uint64_t v_184 = seed.word(87); + const uint64_t v_185 = seed.word(88); + const uint64_t v_186 = seed.word(89); + const uint64_t v_187 = seed.word(90); + const uint64_t v_188 = seed.word(91); + const uint64_t v_189 = seed.word(92); + const uint64_t v_190 = seed.word(93); + const uint64_t v_191 = seed.word(94); + row[layout.auxiliaries + 79] = v_181; + row[layout.auxiliaries + 80] = v_182; + row[layout.auxiliaries + 81] = v_183; + row[layout.auxiliaries + 82] = v_184; + row[layout.auxiliaries + 83] = v_185; + row[layout.auxiliaries + 84] = v_186; + row[layout.auxiliaries + 85] = v_187; + row[layout.auxiliaries + 86] = v_188; + row[layout.auxiliaries + 87] = v_189; + row[layout.auxiliaries + 88] = v_190; + row[layout.auxiliaries + 89] = v_191; + const uint64_t v_201 = seed.word(95); + const uint64_t v_202 = seed.word(96); + const uint64_t v_203 = seed.word(97); + const uint64_t v_204 = seed.word(98); + const uint64_t v_205 = seed.word(99); + const uint64_t v_206 = seed.word(100); + const uint64_t v_207 = seed.word(101); + const uint64_t v_208 = seed.word(102); + const uint64_t v_209 = seed.word(103); + const uint64_t v_210 = seed.word(104); + row[layout.auxiliaries + 90] = v_201; + row[layout.auxiliaries + 91] = v_202; + row[layout.auxiliaries + 92] = v_203; + row[layout.auxiliaries + 93] = v_204; + row[layout.auxiliaries + 94] = v_205; + row[layout.auxiliaries + 95] = v_206; + row[layout.auxiliaries + 96] = v_207; + row[layout.auxiliaries + 97] = v_208; + row[layout.auxiliaries + 98] = v_209; + row[layout.auxiliaries + 99] = v_210; + uint64_t v_217; + switch (v_201) { + case 1ULL: { + const uint64_t v_211 = seed.word(105); + const uint64_t v_212 = seed.word(106); + const uint64_t v_213 = seed.word(107); + row[layout.auxiliaries + 100] = v_211; + row[layout.auxiliaries + 101] = v_212; + row[layout.auxiliaries + 102] = v_213; + switch (v_211) { + case 1ULL: { + const uint64_t v_214 = 1ULL; + row[layout.selectors + 9] = 1; + v_217 = v_214; + goto continuation_9; + } + default: { + row[layout.auxiliaries + 103] = (v_211 <= 1ULL ? inverse_117_10[v_211] : inverse(goldilocks_sub(v_211, 1ULL))); + const uint64_t v_215 = 0ULL; + row[layout.selectors + 10] = 1; + v_217 = v_215; + goto continuation_9; + } + } + } + default: { + row[layout.auxiliaries + 100] = (v_201 <= 1ULL ? inverse_117_11[v_201] : inverse(goldilocks_sub(v_201, 1ULL))); + const uint64_t v_216 = 0ULL; + row[layout.selectors + 11] = 1; + v_217 = v_216; + goto continuation_9; + } + } + continuation_9:; + row[layout.auxiliaries + 104] = v_217; + const uint64_t v_218 = 15ULL; + const uint64_t v_219 = goldilocks_sub(v_2, v_218); + const uint64_t v_220 = uint64_t(v_219 == 0); + row[layout.auxiliaries + 105] = inverse(v_219); + row[layout.auxiliaries + 106] = v_220; + const uint64_t v_221 = uint64_t(v_2 == 0); + row[layout.auxiliaries + 107] = inverse(v_2); + row[layout.auxiliaries + 108] = v_221; + const uint64_t v_222 = goldilocks_mul(v_217, v_220); + row[layout.auxiliaries + 109] = v_222; + const uint64_t v_225 = seed.word(108); + const uint64_t v_226 = seed.word(109); + const uint64_t v_227 = seed.word(110); + const uint64_t v_228 = seed.word(111); + const uint64_t v_229 = seed.word(112); + const uint64_t v_230 = seed.word(113); + const uint64_t v_231 = seed.word(114); + const uint64_t v_232 = seed.word(115); + row[layout.auxiliaries + 110] = v_225; + row[layout.auxiliaries + 111] = v_226; + row[layout.auxiliaries + 112] = v_227; + row[layout.auxiliaries + 113] = v_228; + row[layout.auxiliaries + 114] = v_229; + row[layout.auxiliaries + 115] = v_230; + row[layout.auxiliaries + 116] = v_231; + row[layout.auxiliaries + 117] = v_232; + const uint64_t v_233 = seed.word(116); + row[layout.auxiliaries + 118] = v_233; + const uint64_t v_234 = goldilocks_mul(v_217, v_233); + row[layout.auxiliaries + 119] = v_234; + const uint64_t v_241 = seed.word(117); + const uint64_t v_242 = seed.word(118); + const uint64_t v_243 = seed.word(119); + const uint64_t v_244 = seed.word(120); + const uint64_t v_245 = seed.word(121); + const uint64_t v_246 = seed.word(122); + const uint64_t v_247 = seed.word(123); + const uint64_t v_248 = seed.word(124); + const uint64_t v_249 = seed.word(125); + const uint64_t v_250 = seed.word(126); + const uint64_t v_251 = seed.word(127); + const uint64_t v_252 = seed.word(128); + const uint64_t v_253 = seed.word(129); + const uint64_t v_254 = seed.word(130); + const uint64_t v_255 = seed.word(131); + const uint64_t v_256 = seed.word(132); + const uint64_t v_257 = seed.word(133); + const uint64_t v_258 = seed.word(134); + const uint64_t v_259 = seed.word(135); + const uint64_t v_260 = seed.word(136); + const uint64_t v_261 = seed.word(137); + const uint64_t v_262 = seed.word(138); + const uint64_t v_263 = seed.word(139); + const uint64_t v_264 = seed.word(140); + const uint64_t v_265 = seed.word(141); + const uint64_t v_266 = seed.word(142); + const uint64_t v_267 = seed.word(143); + const uint64_t v_268 = seed.word(144); + const uint64_t v_269 = seed.word(145); + const uint64_t v_270 = seed.word(146); + const uint64_t v_271 = seed.word(147); + const uint64_t v_272 = seed.word(148); + row[layout.auxiliaries + 120] = v_241; + row[layout.auxiliaries + 121] = v_242; + row[layout.auxiliaries + 122] = v_243; + row[layout.auxiliaries + 123] = v_244; + row[layout.auxiliaries + 124] = v_245; + row[layout.auxiliaries + 125] = v_246; + row[layout.auxiliaries + 126] = v_247; + row[layout.auxiliaries + 127] = v_248; + row[layout.auxiliaries + 128] = v_249; + row[layout.auxiliaries + 129] = v_250; + row[layout.auxiliaries + 130] = v_251; + row[layout.auxiliaries + 131] = v_252; + row[layout.auxiliaries + 132] = v_253; + row[layout.auxiliaries + 133] = v_254; + row[layout.auxiliaries + 134] = v_255; + row[layout.auxiliaries + 135] = v_256; + row[layout.auxiliaries + 136] = v_257; + row[layout.auxiliaries + 137] = v_258; + row[layout.auxiliaries + 138] = v_259; + row[layout.auxiliaries + 139] = v_260; + row[layout.auxiliaries + 140] = v_261; + row[layout.auxiliaries + 141] = v_262; + row[layout.auxiliaries + 142] = v_263; + row[layout.auxiliaries + 143] = v_264; + row[layout.auxiliaries + 144] = v_265; + row[layout.auxiliaries + 145] = v_266; + row[layout.auxiliaries + 146] = v_267; + row[layout.auxiliaries + 147] = v_268; + row[layout.auxiliaries + 148] = v_269; + row[layout.auxiliaries + 149] = v_270; + row[layout.auxiliaries + 150] = v_271; + row[layout.auxiliaries + 151] = v_272; + const uint64_t v_289 = seed.word(149); + const uint64_t v_290 = seed.word(150); + const uint64_t v_291 = seed.word(151); + const uint64_t v_292 = seed.word(152); + const uint64_t v_293 = seed.word(153); + const uint64_t v_294 = seed.word(154); + const uint64_t v_295 = seed.word(155); + const uint64_t v_296 = seed.word(156); + const uint64_t v_297 = seed.word(157); + const uint64_t v_298 = seed.word(158); + const uint64_t v_299 = seed.word(159); + const uint64_t v_300 = seed.word(160); + const uint64_t v_301 = seed.word(161); + const uint64_t v_302 = seed.word(162); + const uint64_t v_303 = seed.word(163); + const uint64_t v_304 = seed.word(164); + const uint64_t v_305 = seed.word(165); + const uint64_t v_306 = seed.word(166); + const uint64_t v_307 = seed.word(167); + const uint64_t v_308 = seed.word(168); + const uint64_t v_309 = seed.word(169); + const uint64_t v_310 = seed.word(170); + const uint64_t v_311 = seed.word(171); + const uint64_t v_312 = seed.word(172); + const uint64_t v_313 = seed.word(173); + const uint64_t v_314 = seed.word(174); + const uint64_t v_315 = seed.word(175); + const uint64_t v_316 = seed.word(176); + const uint64_t v_317 = seed.word(177); + const uint64_t v_318 = seed.word(178); + const uint64_t v_319 = seed.word(179); + const uint64_t v_320 = seed.word(180); + row[layout.auxiliaries + 152] = v_289; + row[layout.auxiliaries + 153] = v_290; + row[layout.auxiliaries + 154] = v_291; + row[layout.auxiliaries + 155] = v_292; + row[layout.auxiliaries + 156] = v_293; + row[layout.auxiliaries + 157] = v_294; + row[layout.auxiliaries + 158] = v_295; + row[layout.auxiliaries + 159] = v_296; + row[layout.auxiliaries + 160] = v_297; + row[layout.auxiliaries + 161] = v_298; + row[layout.auxiliaries + 162] = v_299; + row[layout.auxiliaries + 163] = v_300; + row[layout.auxiliaries + 164] = v_301; + row[layout.auxiliaries + 165] = v_302; + row[layout.auxiliaries + 166] = v_303; + row[layout.auxiliaries + 167] = v_304; + row[layout.auxiliaries + 168] = v_305; + row[layout.auxiliaries + 169] = v_306; + row[layout.auxiliaries + 170] = v_307; + row[layout.auxiliaries + 171] = v_308; + row[layout.auxiliaries + 172] = v_309; + row[layout.auxiliaries + 173] = v_310; + row[layout.auxiliaries + 174] = v_311; + row[layout.auxiliaries + 175] = v_312; + row[layout.auxiliaries + 176] = v_313; + row[layout.auxiliaries + 177] = v_314; + row[layout.auxiliaries + 178] = v_315; + row[layout.auxiliaries + 179] = v_316; + row[layout.auxiliaries + 180] = v_317; + row[layout.auxiliaries + 181] = v_318; + row[layout.auxiliaries + 182] = v_319; + row[layout.auxiliaries + 183] = v_320; + switch (v_217) { + case 1ULL: { + const uint64_t v_322 = seed.word(181); + row[layout.auxiliaries + 184] = v_322; + row[layout.selectors + 12] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 184] = (v_217 <= 1ULL ? inverse_117_12[v_217] : inverse(goldilocks_sub(v_217, 1ULL))); + switch (v_220) { + case 1ULL: { + const uint64_t v_355 = seed.word(181); + const uint64_t v_356 = seed.word(182); + const uint64_t v_357 = seed.word(183); + const uint64_t v_358 = seed.word(184); + const uint64_t v_359 = seed.word(185); + const uint64_t v_360 = seed.word(186); + const uint64_t v_361 = seed.word(187); + const uint64_t v_362 = seed.word(188); + row[layout.auxiliaries + 185] = v_355; + row[layout.auxiliaries + 186] = v_356; + row[layout.auxiliaries + 187] = v_357; + row[layout.auxiliaries + 188] = v_358; + row[layout.auxiliaries + 189] = v_359; + row[layout.auxiliaries + 190] = v_360; + row[layout.auxiliaries + 191] = v_361; + row[layout.auxiliaries + 192] = v_362; + const uint64_t v_363 = seed.word(189); + const uint64_t v_364 = seed.word(190); + const uint64_t v_365 = seed.word(191); + const uint64_t v_366 = seed.word(192); + const uint64_t v_367 = seed.word(193); + const uint64_t v_368 = seed.word(194); + const uint64_t v_369 = seed.word(195); + const uint64_t v_370 = seed.word(196); + row[layout.auxiliaries + 193] = v_363; + row[layout.auxiliaries + 194] = v_364; + row[layout.auxiliaries + 195] = v_365; + row[layout.auxiliaries + 196] = v_366; + row[layout.auxiliaries + 197] = v_367; + row[layout.auxiliaries + 198] = v_368; + row[layout.auxiliaries + 199] = v_369; + row[layout.auxiliaries + 200] = v_370; + const uint64_t v_371 = seed.word(197); + row[layout.auxiliaries + 201] = v_371; + const uint64_t v_372 = seed.word(198); + row[layout.auxiliaries + 202] = v_372; + const uint64_t v_373 = seed.word(199); + row[layout.auxiliaries + 203] = v_373; + const uint64_t v_374 = seed.word(200); + row[layout.auxiliaries + 204] = v_374; + row[layout.selectors + 13] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 185] = (v_220 <= 1ULL ? inverse_117_13[v_220] : inverse(goldilocks_sub(v_220, 1ULL))); + const uint64_t v_377 = seed.word(181); + row[layout.auxiliaries + 186] = v_377; + const uint64_t v_378 = seed.word(182); + row[layout.auxiliaries + 187] = v_378; + row[layout.selectors + 14] = 1; + return 0; + } + } + } + } + } + } +} +template __global__ void kernel_ix_aggr_117(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 544 : 1608; + const Seed_ix_aggr_117 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_117(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_117(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_117<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_117<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_117(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 15 || width < auxiliaries || width - auxiliaries < 205) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 544 : encoding == 0 ? 1608 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_117); +} + +template struct Seed_ix_aggr_220 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 32); + case 4: return load_u32(data + 16); + case 5: return load_u32(data + 20); + case 6: return load_u8(data + 33); + case 7: return load_u32(data + 24); + case 8: return load_u32(data + 28); + case 9: return load_u8(data + 34); + case 10: return load_u8(data + 35); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_220(Seed_ix_aggr_220 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_9 = seed.word(6); + const uint64_t v_10 = seed.word(7); + const uint64_t v_11 = seed.word(8); + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + switch (v_9) { + case 0ULL: { + const uint64_t v_12 = seed.word(9); + row[layout.auxiliaries + 7] = v_12; + const uint64_t v_14 = seed.word(10); + row[layout.auxiliaries + 8] = v_14; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ix_aggr_220(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 88; + const Seed_ix_aggr_220 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_220(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_220(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_220<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_220<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_220(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_220); +} + +template struct Seed_ix_aggr_230 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 72); + case 2: return load_u8(data + 73); + case 3: return load_u8(data + 74); + case 4: return load_u8(data + 75); + case 5: return load_u8(data + 76); + case 6: return load_u8(data + 77); + case 7: return load_u8(data + 78); + case 8: return load_u8(data + 79); + case 9: return load_u8(data + 80); + case 10: return load_u8(data + 81); + case 11: return load_u8(data + 82); + case 12: return load_u8(data + 83); + case 13: return load_u8(data + 84); + case 14: return load_u8(data + 85); + case 15: return load_u8(data + 86); + case 16: return load_u8(data + 87); + case 17: return load_u64(data + 8); + case 18: return load_u64(data + 16); + case 19: return load_u64(data + 24); + case 20: return load_u64(data + 32); + case 21: return load_u64(data + 40); + case 22: return load_u64(data + 48); + case 23: return load_u64(data + 56); + case 24: return load_u64(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ix_aggr_230(Seed_ix_aggr_230 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_17 = seed.word(17); + row[layout.auxiliaries + 1] = v_17; + const uint64_t v_18 = seed.word(18); + row[layout.auxiliaries + 2] = v_18; + const uint64_t v_19 = seed.word(19); + row[layout.auxiliaries + 3] = v_19; + const uint64_t v_20 = seed.word(20); + row[layout.auxiliaries + 4] = v_20; + const uint64_t v_21 = seed.word(21); + row[layout.auxiliaries + 5] = v_21; + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 6] = v_22; + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 7] = v_23; + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 8] = v_24; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ix_aggr_230(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 200; + const Seed_ix_aggr_230 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ix_aggr_230(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ix_aggr_230(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ix_aggr_230<<>>(seeds, real, rows, layout, output, error); + else kernel_ix_aggr_230<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ix_aggr_230(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_230); +} + +extern "C" const uint8_t* aiur_trace_ix_aggr_contract() { + static const uint8_t hash[32] = {187, 28, 234, 211, 2, 117, 245, 27, 105, 215, 208, 29, 121, 223, 99, 160, 204, 146, 145, 61, 215, 153, 253, 154, 131, 64, 84, 54, 111, 142, 52, 188}; + return hash; +} +extern "C" const uint8_t* aiur_trace_ix_aggr_schema() { + static const uint8_t hash[32] = {249, 214, 235, 36, 170, 180, 109, 126, 100, 46, 206, 6, 228, 84, 34, 205, 31, 35, 197, 64, 229, 223, 94, 246, 213, 87, 208, 102, 251, 132, 31, 243}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/ixvm.cu b/crates/aiur/cuda/generated/production/ixvm.cu new file mode 100644 index 000000000..03d32f9da --- /dev/null +++ b/crates/aiur/cuda/generated/production/ixvm.cu @@ -0,0 +1,20883 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_ixvm { +using namespace aiur_trace; + +template struct Seed_ixvm_15 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + case 13: return load_u8(data + 20); + case 14: return load_u8(data + 21); + case 15: return load_u8(data + 22); + case 16: return load_u8(data + 23); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_15(Seed_ixvm_15 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + if (v_0 > 255 || v_8 > 255) return 1; + const uint64_t v_16 = ((v_0 + v_8) & 255ULL); + const uint64_t v_17 = ((v_0 + v_8) >> 8); + row[layout.auxiliaries + 1] = v_16; + if (v_1 > 255 || v_9 > 255) return 1; + const uint64_t v_18 = ((v_1 + v_9) & 255ULL); + const uint64_t v_19 = ((v_1 + v_9) >> 8); + row[layout.auxiliaries + 2] = v_18; + if (v_18 > 255 || v_17 > 255) return 1; + const uint64_t v_20 = ((v_18 + v_17) & 255ULL); + const uint64_t v_21 = ((v_18 + v_17) >> 8); + row[layout.auxiliaries + 3] = v_20; + const uint64_t v_22 = goldilocks_add(v_19, v_21); + if (v_2 > 255 || v_10 > 255) return 1; + const uint64_t v_23 = ((v_2 + v_10) & 255ULL); + const uint64_t v_24 = ((v_2 + v_10) >> 8); + row[layout.auxiliaries + 4] = v_23; + if (v_23 > 255 || v_22 > 255) return 1; + const uint64_t v_25 = ((v_23 + v_22) & 255ULL); + const uint64_t v_26 = ((v_23 + v_22) >> 8); + row[layout.auxiliaries + 5] = v_25; + const uint64_t v_27 = goldilocks_add(v_24, v_26); + if (v_3 > 255 || v_11 > 255) return 1; + const uint64_t v_28 = ((v_3 + v_11) & 255ULL); + const uint64_t v_29 = ((v_3 + v_11) >> 8); + row[layout.auxiliaries + 6] = v_28; + if (v_28 > 255 || v_27 > 255) return 1; + const uint64_t v_30 = ((v_28 + v_27) & 255ULL); + const uint64_t v_31 = ((v_28 + v_27) >> 8); + row[layout.auxiliaries + 7] = v_30; + const uint64_t v_32 = goldilocks_add(v_29, v_31); + if (v_4 > 255 || v_12 > 255) return 1; + const uint64_t v_33 = ((v_4 + v_12) & 255ULL); + const uint64_t v_34 = ((v_4 + v_12) >> 8); + row[layout.auxiliaries + 8] = v_33; + if (v_33 > 255 || v_32 > 255) return 1; + const uint64_t v_35 = ((v_33 + v_32) & 255ULL); + const uint64_t v_36 = ((v_33 + v_32) >> 8); + row[layout.auxiliaries + 9] = v_35; + const uint64_t v_37 = goldilocks_add(v_34, v_36); + if (v_5 > 255 || v_13 > 255) return 1; + const uint64_t v_38 = ((v_5 + v_13) & 255ULL); + const uint64_t v_39 = ((v_5 + v_13) >> 8); + row[layout.auxiliaries + 10] = v_38; + if (v_38 > 255 || v_37 > 255) return 1; + const uint64_t v_40 = ((v_38 + v_37) & 255ULL); + const uint64_t v_41 = ((v_38 + v_37) >> 8); + row[layout.auxiliaries + 11] = v_40; + const uint64_t v_42 = goldilocks_add(v_39, v_41); + if (v_6 > 255 || v_14 > 255) return 1; + const uint64_t v_43 = ((v_6 + v_14) & 255ULL); + const uint64_t v_44 = ((v_6 + v_14) >> 8); + row[layout.auxiliaries + 12] = v_43; + if (v_43 > 255 || v_42 > 255) return 1; + const uint64_t v_45 = ((v_43 + v_42) & 255ULL); + const uint64_t v_46 = ((v_43 + v_42) >> 8); + row[layout.auxiliaries + 13] = v_45; + const uint64_t v_47 = goldilocks_add(v_44, v_46); + if (v_7 > 255 || v_15 > 255) return 1; + const uint64_t v_48 = ((v_7 + v_15) & 255ULL); + const uint64_t v_49 = ((v_7 + v_15) >> 8); + row[layout.auxiliaries + 14] = v_48; + if (v_48 > 255 || v_47 > 255) return 1; + const uint64_t v_50 = ((v_48 + v_47) & 255ULL); + const uint64_t v_51 = ((v_48 + v_47) >> 8); + row[layout.auxiliaries + 15] = v_50; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_15(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 136; + const Seed_ixvm_15 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_15(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_15(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_15<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_15<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_15(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_15); +} + +__device__ __constant__ uint64_t inverse_24_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_24 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 280); + case 2: return load_u8(data + 296); + case 3: return load_u8(data + 297); + case 4: return load_u8(data + 298); + case 5: return load_u8(data + 299); + case 6: return load_u8(data + 300); + case 7: return load_u8(data + 301); + case 8: return load_u8(data + 302); + case 9: return load_u8(data + 303); + case 10: return load_u8(data + 304); + case 11: return load_u8(data + 305); + case 12: return load_u8(data + 306); + case 13: return load_u8(data + 307); + case 14: return load_u8(data + 308); + case 15: return load_u8(data + 309); + case 16: return load_u8(data + 310); + case 17: return load_u8(data + 311); + case 18: return load_u8(data + 312); + case 19: return load_u8(data + 313); + case 20: return load_u8(data + 314); + case 21: return load_u8(data + 315); + case 22: return load_u8(data + 316); + case 23: return load_u8(data + 317); + case 24: return load_u8(data + 318); + case 25: return load_u8(data + 319); + case 26: return load_u8(data + 320); + case 27: return load_u8(data + 321); + case 28: return load_u8(data + 322); + case 29: return load_u8(data + 323); + case 30: return load_u8(data + 324); + case 31: return load_u8(data + 325); + case 32: return load_u8(data + 326); + case 33: return load_u8(data + 327); + case 34: return load_u64(data + 8); + case 35: return load_u8(data + 328); + case 36: return load_u32(data + 284); + case 37: return load_u8(data + 329); + case 38: return load_u8(data + 330); + case 39: return load_u8(data + 331); + case 40: return load_u8(data + 332); + case 41: return load_u8(data + 333); + case 42: return load_u8(data + 334); + case 43: return load_u8(data + 335); + case 44: return load_u8(data + 336); + case 45: return load_u8(data + 337); + case 46: return load_u8(data + 338); + case 47: return load_u8(data + 339); + case 48: return load_u8(data + 340); + case 49: return load_u8(data + 341); + case 50: return load_u8(data + 342); + case 51: return load_u8(data + 343); + case 52: return load_u8(data + 344); + case 53: return load_u8(data + 345); + case 54: return load_u8(data + 346); + case 55: return load_u8(data + 347); + case 56: return load_u8(data + 348); + case 57: return load_u8(data + 349); + case 58: return load_u8(data + 350); + case 59: return load_u8(data + 351); + case 60: return load_u8(data + 352); + case 61: return load_u8(data + 353); + case 62: return load_u8(data + 354); + case 63: return load_u8(data + 355); + case 64: return load_u8(data + 356); + case 65: return load_u8(data + 357); + case 66: return load_u8(data + 358); + case 67: return load_u8(data + 359); + case 68: return load_u8(data + 360); + case 69: return load_u8(data + 361); + case 70: return load_u8(data + 362); + case 71: return load_u8(data + 363); + case 72: return load_u8(data + 364); + case 73: return load_u8(data + 365); + case 74: return load_u8(data + 366); + case 75: return load_u8(data + 367); + case 76: return load_u8(data + 368); + case 77: return load_u8(data + 369); + case 78: return load_u8(data + 370); + case 79: return load_u8(data + 371); + case 80: return load_u8(data + 372); + case 81: return load_u8(data + 373); + case 82: return load_u8(data + 374); + case 83: return load_u8(data + 375); + case 84: return load_u8(data + 376); + case 85: return load_u8(data + 377); + case 86: return load_u8(data + 378); + case 87: return load_u8(data + 379); + case 88: return load_u8(data + 380); + case 89: return load_u8(data + 381); + case 90: return load_u8(data + 382); + case 91: return load_u8(data + 383); + case 92: return load_u8(data + 384); + case 93: return load_u8(data + 385); + case 94: return load_u8(data + 386); + case 95: return load_u8(data + 387); + case 96: return load_u8(data + 388); + case 97: return load_u8(data + 389); + case 98: return load_u8(data + 390); + case 99: return load_u8(data + 391); + case 100: return load_u8(data + 392); + case 101: return load_u8(data + 393); + case 102: return load_u32(data + 288); + case 103: return load_u8(data + 394); + case 104: return load_u64(data + 16); + case 105: return load_u64(data + 24); + case 106: return load_u64(data + 32); + case 107: return load_u64(data + 40); + case 108: return load_u64(data + 48); + case 109: return load_u64(data + 56); + case 110: return load_u64(data + 64); + case 111: return load_u64(data + 72); + case 112: return load_u64(data + 80); + case 113: return load_u64(data + 88); + case 114: return load_u64(data + 96); + case 115: return load_u64(data + 104); + case 116: return load_u64(data + 112); + case 117: return load_u64(data + 120); + case 118: return load_u64(data + 128); + case 119: return load_u64(data + 136); + case 120: return load_u64(data + 144); + case 121: return load_u64(data + 152); + case 122: return load_u64(data + 160); + case 123: return load_u64(data + 168); + case 124: return load_u64(data + 176); + case 125: return load_u64(data + 184); + case 126: return load_u64(data + 192); + case 127: return load_u64(data + 200); + case 128: return load_u64(data + 208); + case 129: return load_u64(data + 216); + case 130: return load_u64(data + 224); + case 131: return load_u64(data + 232); + case 132: return load_u64(data + 240); + case 133: return load_u64(data + 248); + case 134: return load_u64(data + 256); + case 135: return load_u64(data + 264); + case 136: return load_u64(data + 272); + case 137: return load_u8(data + 395); + case 138: return load_u8(data + 396); + case 139: return load_u8(data + 397); + case 140: return load_u8(data + 398); + case 141: return load_u8(data + 399); + case 142: return load_u8(data + 400); + case 143: return load_u8(data + 401); + case 144: return load_u8(data + 402); + case 145: return load_u8(data + 403); + case 146: return load_u8(data + 404); + case 147: return load_u8(data + 405); + case 148: return load_u8(data + 406); + case 149: return load_u8(data + 407); + case 150: return load_u8(data + 408); + case 151: return load_u8(data + 409); + case 152: return load_u8(data + 410); + case 153: return load_u8(data + 411); + case 154: return load_u8(data + 412); + case 155: return load_u8(data + 413); + case 156: return load_u8(data + 414); + case 157: return load_u8(data + 415); + case 158: return load_u8(data + 416); + case 159: return load_u8(data + 417); + case 160: return load_u8(data + 418); + case 161: return load_u8(data + 419); + case 162: return load_u8(data + 420); + case 163: return load_u8(data + 421); + case 164: return load_u8(data + 422); + case 165: return load_u8(data + 423); + case 166: return load_u8(data + 424); + case 167: return load_u8(data + 425); + case 168: return load_u8(data + 426); + case 169: return load_u32(data + 292); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_24(Seed_ixvm_24 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + const uint64_t v_67 = seed.word(68); + row[layout.auxiliaries + 1] = v_34; + row[layout.auxiliaries + 2] = v_35; + row[layout.auxiliaries + 3] = v_36; + row[layout.auxiliaries + 4] = v_37; + row[layout.auxiliaries + 5] = v_38; + row[layout.auxiliaries + 6] = v_39; + row[layout.auxiliaries + 7] = v_40; + row[layout.auxiliaries + 8] = v_41; + row[layout.auxiliaries + 9] = v_42; + row[layout.auxiliaries + 10] = v_43; + row[layout.auxiliaries + 11] = v_44; + row[layout.auxiliaries + 12] = v_45; + row[layout.auxiliaries + 13] = v_46; + row[layout.auxiliaries + 14] = v_47; + row[layout.auxiliaries + 15] = v_48; + row[layout.auxiliaries + 16] = v_49; + row[layout.auxiliaries + 17] = v_50; + row[layout.auxiliaries + 18] = v_51; + row[layout.auxiliaries + 19] = v_52; + row[layout.auxiliaries + 20] = v_53; + row[layout.auxiliaries + 21] = v_54; + row[layout.auxiliaries + 22] = v_55; + row[layout.auxiliaries + 23] = v_56; + row[layout.auxiliaries + 24] = v_57; + row[layout.auxiliaries + 25] = v_58; + row[layout.auxiliaries + 26] = v_59; + row[layout.auxiliaries + 27] = v_60; + row[layout.auxiliaries + 28] = v_61; + row[layout.auxiliaries + 29] = v_62; + row[layout.auxiliaries + 30] = v_63; + row[layout.auxiliaries + 31] = v_64; + row[layout.auxiliaries + 32] = v_65; + row[layout.auxiliaries + 33] = v_66; + row[layout.auxiliaries + 34] = v_67; + switch (v_34) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_70 = seed.word(69); + const uint64_t v_71 = seed.word(70); + const uint64_t v_72 = seed.word(71); + const uint64_t v_73 = seed.word(72); + const uint64_t v_74 = seed.word(73); + const uint64_t v_75 = seed.word(74); + const uint64_t v_76 = seed.word(75); + const uint64_t v_77 = seed.word(76); + const uint64_t v_78 = seed.word(77); + const uint64_t v_79 = seed.word(78); + const uint64_t v_80 = seed.word(79); + const uint64_t v_81 = seed.word(80); + const uint64_t v_82 = seed.word(81); + const uint64_t v_83 = seed.word(82); + const uint64_t v_84 = seed.word(83); + const uint64_t v_85 = seed.word(84); + const uint64_t v_86 = seed.word(85); + const uint64_t v_87 = seed.word(86); + const uint64_t v_88 = seed.word(87); + const uint64_t v_89 = seed.word(88); + const uint64_t v_90 = seed.word(89); + const uint64_t v_91 = seed.word(90); + const uint64_t v_92 = seed.word(91); + const uint64_t v_93 = seed.word(92); + const uint64_t v_94 = seed.word(93); + const uint64_t v_95 = seed.word(94); + const uint64_t v_96 = seed.word(95); + const uint64_t v_97 = seed.word(96); + const uint64_t v_98 = seed.word(97); + const uint64_t v_99 = seed.word(98); + const uint64_t v_100 = seed.word(99); + const uint64_t v_101 = seed.word(100); + const uint64_t v_102 = seed.word(101); + const uint64_t v_103 = seed.word(102); + row[layout.auxiliaries + 35] = v_70; + row[layout.auxiliaries + 36] = v_71; + row[layout.auxiliaries + 37] = v_72; + row[layout.auxiliaries + 38] = v_73; + row[layout.auxiliaries + 39] = v_74; + row[layout.auxiliaries + 40] = v_75; + row[layout.auxiliaries + 41] = v_76; + row[layout.auxiliaries + 42] = v_77; + row[layout.auxiliaries + 43] = v_78; + row[layout.auxiliaries + 44] = v_79; + row[layout.auxiliaries + 45] = v_80; + row[layout.auxiliaries + 46] = v_81; + row[layout.auxiliaries + 47] = v_82; + row[layout.auxiliaries + 48] = v_83; + row[layout.auxiliaries + 49] = v_84; + row[layout.auxiliaries + 50] = v_85; + row[layout.auxiliaries + 51] = v_86; + row[layout.auxiliaries + 52] = v_87; + row[layout.auxiliaries + 53] = v_88; + row[layout.auxiliaries + 54] = v_89; + row[layout.auxiliaries + 55] = v_90; + row[layout.auxiliaries + 56] = v_91; + row[layout.auxiliaries + 57] = v_92; + row[layout.auxiliaries + 58] = v_93; + row[layout.auxiliaries + 59] = v_94; + row[layout.auxiliaries + 60] = v_95; + row[layout.auxiliaries + 61] = v_96; + row[layout.auxiliaries + 62] = v_97; + row[layout.auxiliaries + 63] = v_98; + row[layout.auxiliaries + 64] = v_99; + row[layout.auxiliaries + 65] = v_100; + row[layout.auxiliaries + 66] = v_101; + row[layout.auxiliaries + 67] = v_102; + row[layout.auxiliaries + 68] = v_103; + switch (v_70) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_138 = seed.word(103); + const uint64_t v_139 = seed.word(104); + const uint64_t v_140 = seed.word(105); + const uint64_t v_141 = seed.word(106); + const uint64_t v_142 = seed.word(107); + const uint64_t v_143 = seed.word(108); + const uint64_t v_144 = seed.word(109); + const uint64_t v_145 = seed.word(110); + const uint64_t v_146 = seed.word(111); + const uint64_t v_147 = seed.word(112); + const uint64_t v_148 = seed.word(113); + const uint64_t v_149 = seed.word(114); + const uint64_t v_150 = seed.word(115); + const uint64_t v_151 = seed.word(116); + const uint64_t v_152 = seed.word(117); + const uint64_t v_153 = seed.word(118); + const uint64_t v_154 = seed.word(119); + const uint64_t v_155 = seed.word(120); + const uint64_t v_156 = seed.word(121); + const uint64_t v_157 = seed.word(122); + const uint64_t v_158 = seed.word(123); + const uint64_t v_159 = seed.word(124); + const uint64_t v_160 = seed.word(125); + const uint64_t v_161 = seed.word(126); + const uint64_t v_162 = seed.word(127); + const uint64_t v_163 = seed.word(128); + const uint64_t v_164 = seed.word(129); + const uint64_t v_165 = seed.word(130); + const uint64_t v_166 = seed.word(131); + const uint64_t v_167 = seed.word(132); + const uint64_t v_168 = seed.word(133); + const uint64_t v_169 = seed.word(134); + const uint64_t v_170 = seed.word(135); + const uint64_t v_171 = seed.word(136); + row[layout.auxiliaries + 69] = v_138; + row[layout.auxiliaries + 70] = v_139; + row[layout.auxiliaries + 71] = v_140; + row[layout.auxiliaries + 72] = v_141; + row[layout.auxiliaries + 73] = v_142; + row[layout.auxiliaries + 74] = v_143; + row[layout.auxiliaries + 75] = v_144; + row[layout.auxiliaries + 76] = v_145; + row[layout.auxiliaries + 77] = v_146; + row[layout.auxiliaries + 78] = v_147; + row[layout.auxiliaries + 79] = v_148; + row[layout.auxiliaries + 80] = v_149; + row[layout.auxiliaries + 81] = v_150; + row[layout.auxiliaries + 82] = v_151; + row[layout.auxiliaries + 83] = v_152; + row[layout.auxiliaries + 84] = v_153; + row[layout.auxiliaries + 85] = v_154; + row[layout.auxiliaries + 86] = v_155; + row[layout.auxiliaries + 87] = v_156; + row[layout.auxiliaries + 88] = v_157; + row[layout.auxiliaries + 89] = v_158; + row[layout.auxiliaries + 90] = v_159; + row[layout.auxiliaries + 91] = v_160; + row[layout.auxiliaries + 92] = v_161; + row[layout.auxiliaries + 93] = v_162; + row[layout.auxiliaries + 94] = v_163; + row[layout.auxiliaries + 95] = v_164; + row[layout.auxiliaries + 96] = v_165; + row[layout.auxiliaries + 97] = v_166; + row[layout.auxiliaries + 98] = v_167; + row[layout.auxiliaries + 99] = v_168; + row[layout.auxiliaries + 100] = v_169; + row[layout.auxiliaries + 101] = v_170; + row[layout.auxiliaries + 102] = v_171; + switch (v_138) { + case 1ULL: { + const uint64_t v_191 = seed.word(137); + const uint64_t v_192 = seed.word(138); + const uint64_t v_193 = seed.word(139); + const uint64_t v_194 = seed.word(140); + const uint64_t v_195 = seed.word(141); + const uint64_t v_196 = seed.word(142); + const uint64_t v_197 = seed.word(143); + const uint64_t v_198 = seed.word(144); + const uint64_t v_199 = seed.word(145); + const uint64_t v_200 = seed.word(146); + const uint64_t v_201 = seed.word(147); + const uint64_t v_202 = seed.word(148); + const uint64_t v_203 = seed.word(149); + const uint64_t v_204 = seed.word(150); + const uint64_t v_205 = seed.word(151); + const uint64_t v_206 = seed.word(152); + const uint64_t v_207 = seed.word(153); + const uint64_t v_208 = seed.word(154); + const uint64_t v_209 = seed.word(155); + const uint64_t v_210 = seed.word(156); + const uint64_t v_211 = seed.word(157); + const uint64_t v_212 = seed.word(158); + const uint64_t v_213 = seed.word(159); + const uint64_t v_214 = seed.word(160); + const uint64_t v_215 = seed.word(161); + const uint64_t v_216 = seed.word(162); + const uint64_t v_217 = seed.word(163); + const uint64_t v_218 = seed.word(164); + const uint64_t v_219 = seed.word(165); + const uint64_t v_220 = seed.word(166); + const uint64_t v_221 = seed.word(167); + const uint64_t v_222 = seed.word(168); + row[layout.auxiliaries + 103] = v_191; + row[layout.auxiliaries + 104] = v_192; + row[layout.auxiliaries + 105] = v_193; + row[layout.auxiliaries + 106] = v_194; + row[layout.auxiliaries + 107] = v_195; + row[layout.auxiliaries + 108] = v_196; + row[layout.auxiliaries + 109] = v_197; + row[layout.auxiliaries + 110] = v_198; + row[layout.auxiliaries + 111] = v_199; + row[layout.auxiliaries + 112] = v_200; + row[layout.auxiliaries + 113] = v_201; + row[layout.auxiliaries + 114] = v_202; + row[layout.auxiliaries + 115] = v_203; + row[layout.auxiliaries + 116] = v_204; + row[layout.auxiliaries + 117] = v_205; + row[layout.auxiliaries + 118] = v_206; + row[layout.auxiliaries + 119] = v_207; + row[layout.auxiliaries + 120] = v_208; + row[layout.auxiliaries + 121] = v_209; + row[layout.auxiliaries + 122] = v_210; + row[layout.auxiliaries + 123] = v_211; + row[layout.auxiliaries + 124] = v_212; + row[layout.auxiliaries + 125] = v_213; + row[layout.auxiliaries + 126] = v_214; + row[layout.auxiliaries + 127] = v_215; + row[layout.auxiliaries + 128] = v_216; + row[layout.auxiliaries + 129] = v_217; + row[layout.auxiliaries + 130] = v_218; + row[layout.auxiliaries + 131] = v_219; + row[layout.auxiliaries + 132] = v_220; + row[layout.auxiliaries + 133] = v_221; + row[layout.auxiliaries + 134] = v_222; + const uint64_t v_223 = seed.word(169); + row[layout.auxiliaries + 135] = v_223; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 103] = (v_138 <= 1ULL ? inverse_24_0[v_138] : inverse(goldilocks_sub(v_138, 1ULL))); + const uint64_t v_241 = seed.word(137); + const uint64_t v_242 = seed.word(138); + const uint64_t v_243 = seed.word(139); + const uint64_t v_244 = seed.word(140); + const uint64_t v_245 = seed.word(141); + const uint64_t v_246 = seed.word(142); + const uint64_t v_247 = seed.word(143); + const uint64_t v_248 = seed.word(144); + const uint64_t v_249 = seed.word(145); + const uint64_t v_250 = seed.word(146); + const uint64_t v_251 = seed.word(147); + const uint64_t v_252 = seed.word(148); + const uint64_t v_253 = seed.word(149); + const uint64_t v_254 = seed.word(150); + const uint64_t v_255 = seed.word(151); + const uint64_t v_256 = seed.word(152); + const uint64_t v_257 = seed.word(153); + const uint64_t v_258 = seed.word(154); + const uint64_t v_259 = seed.word(155); + const uint64_t v_260 = seed.word(156); + const uint64_t v_261 = seed.word(157); + const uint64_t v_262 = seed.word(158); + const uint64_t v_263 = seed.word(159); + const uint64_t v_264 = seed.word(160); + const uint64_t v_265 = seed.word(161); + const uint64_t v_266 = seed.word(162); + const uint64_t v_267 = seed.word(163); + const uint64_t v_268 = seed.word(164); + const uint64_t v_269 = seed.word(165); + const uint64_t v_270 = seed.word(166); + const uint64_t v_271 = seed.word(167); + const uint64_t v_272 = seed.word(168); + row[layout.auxiliaries + 104] = v_241; + row[layout.auxiliaries + 105] = v_242; + row[layout.auxiliaries + 106] = v_243; + row[layout.auxiliaries + 107] = v_244; + row[layout.auxiliaries + 108] = v_245; + row[layout.auxiliaries + 109] = v_246; + row[layout.auxiliaries + 110] = v_247; + row[layout.auxiliaries + 111] = v_248; + row[layout.auxiliaries + 112] = v_249; + row[layout.auxiliaries + 113] = v_250; + row[layout.auxiliaries + 114] = v_251; + row[layout.auxiliaries + 115] = v_252; + row[layout.auxiliaries + 116] = v_253; + row[layout.auxiliaries + 117] = v_254; + row[layout.auxiliaries + 118] = v_255; + row[layout.auxiliaries + 119] = v_256; + row[layout.auxiliaries + 120] = v_257; + row[layout.auxiliaries + 121] = v_258; + row[layout.auxiliaries + 122] = v_259; + row[layout.auxiliaries + 123] = v_260; + row[layout.auxiliaries + 124] = v_261; + row[layout.auxiliaries + 125] = v_262; + row[layout.auxiliaries + 126] = v_263; + row[layout.auxiliaries + 127] = v_264; + row[layout.auxiliaries + 128] = v_265; + row[layout.auxiliaries + 129] = v_266; + row[layout.auxiliaries + 130] = v_267; + row[layout.auxiliaries + 131] = v_268; + row[layout.auxiliaries + 132] = v_269; + row[layout.auxiliaries + 133] = v_270; + row[layout.auxiliaries + 134] = v_271; + row[layout.auxiliaries + 135] = v_272; + const uint64_t v_273 = seed.word(169); + row[layout.auxiliaries + 136] = v_273; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_24(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 432 : 1360; + const Seed_ixvm_24 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_24(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_24(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_24<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_24<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_24(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 34 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 137) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 432 : encoding == 0 ? 1360 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_24); +} + +template struct Seed_ixvm_26 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 56); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 72); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 60); + case 6: return load_u32(data + 64); + case 7: return load_u64(data + 24); + case 8: return load_u8(data + 73); + case 9: return load_u64(data + 32); + case 10: return load_u32(data + 68); + case 11: return load_u64(data + 40); + case 12: return load_u64(data + 48); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_26(Seed_ixvm_26 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_7; + row[layout.auxiliaries + 2] = v_8; + row[layout.auxiliaries + 3] = v_9; + switch (v_7) { + case 1ULL: { + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 4] = v_10; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(11); + row[layout.auxiliaries + 4] = v_12; + switch (v_2) { + case 63ULL: { + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 5] = v_13; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 5] = inverse(goldilocks_sub(v_2, 63ULL)); + const uint64_t v_17 = seed.word(12); + row[layout.auxiliaries + 6] = v_17; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_26(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 80 : 104; + const Seed_ixvm_26 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_26(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_26(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_26<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_26<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_26(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 7 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_26); +} + +template struct Seed_ixvm_27 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 528); + case 2: return load_u8(data + 784); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 532); + case 5: return load_u8(data + 785); + case 6: return load_u64(data + 16); + case 7: return load_u32(data + 536); + case 8: return load_u8(data + 786); + case 9: return load_u64(data + 24); + case 10: return load_u32(data + 540); + case 11: return load_u8(data + 787); + case 12: return load_u64(data + 32); + case 13: return load_u32(data + 544); + case 14: return load_u8(data + 788); + case 15: return load_u64(data + 40); + case 16: return load_u32(data + 548); + case 17: return load_u8(data + 789); + case 18: return load_u64(data + 48); + case 19: return load_u32(data + 552); + case 20: return load_u8(data + 790); + case 21: return load_u64(data + 56); + case 22: return load_u32(data + 556); + case 23: return load_u8(data + 791); + case 24: return load_u64(data + 64); + case 25: return load_u32(data + 560); + case 26: return load_u8(data + 792); + case 27: return load_u64(data + 72); + case 28: return load_u32(data + 564); + case 29: return load_u8(data + 793); + case 30: return load_u64(data + 80); + case 31: return load_u32(data + 568); + case 32: return load_u8(data + 794); + case 33: return load_u64(data + 88); + case 34: return load_u32(data + 572); + case 35: return load_u8(data + 795); + case 36: return load_u64(data + 96); + case 37: return load_u32(data + 576); + case 38: return load_u8(data + 796); + case 39: return load_u64(data + 104); + case 40: return load_u32(data + 580); + case 41: return load_u8(data + 797); + case 42: return load_u64(data + 112); + case 43: return load_u32(data + 584); + case 44: return load_u8(data + 798); + case 45: return load_u64(data + 120); + case 46: return load_u32(data + 588); + case 47: return load_u8(data + 799); + case 48: return load_u64(data + 128); + case 49: return load_u32(data + 592); + case 50: return load_u8(data + 800); + case 51: return load_u64(data + 136); + case 52: return load_u32(data + 596); + case 53: return load_u8(data + 801); + case 54: return load_u64(data + 144); + case 55: return load_u32(data + 600); + case 56: return load_u8(data + 802); + case 57: return load_u64(data + 152); + case 58: return load_u32(data + 604); + case 59: return load_u8(data + 803); + case 60: return load_u64(data + 160); + case 61: return load_u32(data + 608); + case 62: return load_u8(data + 804); + case 63: return load_u64(data + 168); + case 64: return load_u32(data + 612); + case 65: return load_u8(data + 805); + case 66: return load_u64(data + 176); + case 67: return load_u32(data + 616); + case 68: return load_u8(data + 806); + case 69: return load_u64(data + 184); + case 70: return load_u32(data + 620); + case 71: return load_u8(data + 807); + case 72: return load_u64(data + 192); + case 73: return load_u32(data + 624); + case 74: return load_u8(data + 808); + case 75: return load_u64(data + 200); + case 76: return load_u32(data + 628); + case 77: return load_u8(data + 809); + case 78: return load_u64(data + 208); + case 79: return load_u32(data + 632); + case 80: return load_u8(data + 810); + case 81: return load_u64(data + 216); + case 82: return load_u32(data + 636); + case 83: return load_u8(data + 811); + case 84: return load_u64(data + 224); + case 85: return load_u32(data + 640); + case 86: return load_u8(data + 812); + case 87: return load_u64(data + 232); + case 88: return load_u32(data + 644); + case 89: return load_u8(data + 813); + case 90: return load_u64(data + 240); + case 91: return load_u32(data + 648); + case 92: return load_u8(data + 814); + case 93: return load_u64(data + 248); + case 94: return load_u32(data + 652); + case 95: return load_u8(data + 815); + case 96: return load_u64(data + 256); + case 97: return load_u32(data + 656); + case 98: return load_u8(data + 816); + case 99: return load_u64(data + 264); + case 100: return load_u32(data + 660); + case 101: return load_u8(data + 817); + case 102: return load_u64(data + 272); + case 103: return load_u32(data + 664); + case 104: return load_u8(data + 818); + case 105: return load_u64(data + 280); + case 106: return load_u32(data + 668); + case 107: return load_u8(data + 819); + case 108: return load_u64(data + 288); + case 109: return load_u32(data + 672); + case 110: return load_u8(data + 820); + case 111: return load_u64(data + 296); + case 112: return load_u32(data + 676); + case 113: return load_u8(data + 821); + case 114: return load_u64(data + 304); + case 115: return load_u32(data + 680); + case 116: return load_u8(data + 822); + case 117: return load_u64(data + 312); + case 118: return load_u32(data + 684); + case 119: return load_u8(data + 823); + case 120: return load_u64(data + 320); + case 121: return load_u32(data + 688); + case 122: return load_u8(data + 824); + case 123: return load_u64(data + 328); + case 124: return load_u32(data + 692); + case 125: return load_u8(data + 825); + case 126: return load_u64(data + 336); + case 127: return load_u32(data + 696); + case 128: return load_u8(data + 826); + case 129: return load_u64(data + 344); + case 130: return load_u32(data + 700); + case 131: return load_u8(data + 827); + case 132: return load_u64(data + 352); + case 133: return load_u32(data + 704); + case 134: return load_u8(data + 828); + case 135: return load_u64(data + 360); + case 136: return load_u32(data + 708); + case 137: return load_u8(data + 829); + case 138: return load_u64(data + 368); + case 139: return load_u32(data + 712); + case 140: return load_u8(data + 830); + case 141: return load_u64(data + 376); + case 142: return load_u32(data + 716); + case 143: return load_u8(data + 831); + case 144: return load_u64(data + 384); + case 145: return load_u32(data + 720); + case 146: return load_u8(data + 832); + case 147: return load_u64(data + 392); + case 148: return load_u32(data + 724); + case 149: return load_u8(data + 833); + case 150: return load_u64(data + 400); + case 151: return load_u32(data + 728); + case 152: return load_u8(data + 834); + case 153: return load_u64(data + 408); + case 154: return load_u32(data + 732); + case 155: return load_u8(data + 835); + case 156: return load_u64(data + 416); + case 157: return load_u32(data + 736); + case 158: return load_u8(data + 836); + case 159: return load_u64(data + 424); + case 160: return load_u32(data + 740); + case 161: return load_u8(data + 837); + case 162: return load_u64(data + 432); + case 163: return load_u32(data + 744); + case 164: return load_u8(data + 838); + case 165: return load_u64(data + 440); + case 166: return load_u32(data + 748); + case 167: return load_u8(data + 839); + case 168: return load_u64(data + 448); + case 169: return load_u32(data + 752); + case 170: return load_u8(data + 840); + case 171: return load_u64(data + 456); + case 172: return load_u32(data + 756); + case 173: return load_u8(data + 841); + case 174: return load_u64(data + 464); + case 175: return load_u32(data + 760); + case 176: return load_u8(data + 842); + case 177: return load_u64(data + 472); + case 178: return load_u32(data + 764); + case 179: return load_u8(data + 843); + case 180: return load_u64(data + 480); + case 181: return load_u32(data + 768); + case 182: return load_u8(data + 844); + case 183: return load_u64(data + 488); + case 184: return load_u32(data + 772); + case 185: return load_u8(data + 845); + case 186: return load_u64(data + 496); + case 187: return load_u32(data + 776); + case 188: return load_u8(data + 846); + case 189: return load_u64(data + 504); + case 190: return load_u32(data + 780); + case 191: return load_u8(data + 847); + case 192: return load_u64(data + 512); + case 193: return load_u64(data + 520); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_27(Seed_ixvm_27 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + switch (v_4) { + case 0ULL: { + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + switch (v_7) { + case 0ULL: { + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + switch (v_10) { + case 0ULL: { + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + switch (v_13) { + case 0ULL: { + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + switch (v_16) { + case 0ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + switch (v_19) { + case 0ULL: { + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + switch (v_22) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + switch (v_25) { + case 0ULL: { + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + switch (v_28) { + case 0ULL: { + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + switch (v_31) { + case 0ULL: { + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + switch (v_34) { + case 0ULL: { + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + row[layout.auxiliaries + 37] = v_37; + row[layout.auxiliaries + 38] = v_38; + row[layout.auxiliaries + 39] = v_39; + switch (v_37) { + case 0ULL: { + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + row[layout.auxiliaries + 40] = v_40; + row[layout.auxiliaries + 41] = v_41; + row[layout.auxiliaries + 42] = v_42; + switch (v_40) { + case 0ULL: { + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + row[layout.auxiliaries + 43] = v_43; + row[layout.auxiliaries + 44] = v_44; + row[layout.auxiliaries + 45] = v_45; + switch (v_43) { + case 0ULL: { + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 46] = v_46; + row[layout.auxiliaries + 47] = v_47; + row[layout.auxiliaries + 48] = v_48; + switch (v_46) { + case 0ULL: { + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 49] = v_49; + row[layout.auxiliaries + 50] = v_50; + row[layout.auxiliaries + 51] = v_51; + switch (v_49) { + case 0ULL: { + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 52] = v_52; + row[layout.auxiliaries + 53] = v_53; + row[layout.auxiliaries + 54] = v_54; + switch (v_52) { + case 0ULL: { + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + row[layout.auxiliaries + 55] = v_55; + row[layout.auxiliaries + 56] = v_56; + row[layout.auxiliaries + 57] = v_57; + switch (v_55) { + case 0ULL: { + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + row[layout.auxiliaries + 58] = v_58; + row[layout.auxiliaries + 59] = v_59; + row[layout.auxiliaries + 60] = v_60; + switch (v_58) { + case 0ULL: { + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + row[layout.auxiliaries + 61] = v_61; + row[layout.auxiliaries + 62] = v_62; + row[layout.auxiliaries + 63] = v_63; + switch (v_61) { + case 0ULL: { + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + row[layout.auxiliaries + 64] = v_64; + row[layout.auxiliaries + 65] = v_65; + row[layout.auxiliaries + 66] = v_66; + switch (v_64) { + case 0ULL: { + const uint64_t v_67 = seed.word(68); + const uint64_t v_68 = seed.word(69); + const uint64_t v_69 = seed.word(70); + row[layout.auxiliaries + 67] = v_67; + row[layout.auxiliaries + 68] = v_68; + row[layout.auxiliaries + 69] = v_69; + switch (v_67) { + case 0ULL: { + const uint64_t v_70 = seed.word(71); + const uint64_t v_71 = seed.word(72); + const uint64_t v_72 = seed.word(73); + row[layout.auxiliaries + 70] = v_70; + row[layout.auxiliaries + 71] = v_71; + row[layout.auxiliaries + 72] = v_72; + switch (v_70) { + case 0ULL: { + const uint64_t v_73 = seed.word(74); + const uint64_t v_74 = seed.word(75); + const uint64_t v_75 = seed.word(76); + row[layout.auxiliaries + 73] = v_73; + row[layout.auxiliaries + 74] = v_74; + row[layout.auxiliaries + 75] = v_75; + switch (v_73) { + case 0ULL: { + const uint64_t v_76 = seed.word(77); + const uint64_t v_77 = seed.word(78); + const uint64_t v_78 = seed.word(79); + row[layout.auxiliaries + 76] = v_76; + row[layout.auxiliaries + 77] = v_77; + row[layout.auxiliaries + 78] = v_78; + switch (v_76) { + case 0ULL: { + const uint64_t v_79 = seed.word(80); + const uint64_t v_80 = seed.word(81); + const uint64_t v_81 = seed.word(82); + row[layout.auxiliaries + 79] = v_79; + row[layout.auxiliaries + 80] = v_80; + row[layout.auxiliaries + 81] = v_81; + switch (v_79) { + case 0ULL: { + const uint64_t v_82 = seed.word(83); + const uint64_t v_83 = seed.word(84); + const uint64_t v_84 = seed.word(85); + row[layout.auxiliaries + 82] = v_82; + row[layout.auxiliaries + 83] = v_83; + row[layout.auxiliaries + 84] = v_84; + switch (v_82) { + case 0ULL: { + const uint64_t v_85 = seed.word(86); + const uint64_t v_86 = seed.word(87); + const uint64_t v_87 = seed.word(88); + row[layout.auxiliaries + 85] = v_85; + row[layout.auxiliaries + 86] = v_86; + row[layout.auxiliaries + 87] = v_87; + switch (v_85) { + case 0ULL: { + const uint64_t v_88 = seed.word(89); + const uint64_t v_89 = seed.word(90); + const uint64_t v_90 = seed.word(91); + row[layout.auxiliaries + 88] = v_88; + row[layout.auxiliaries + 89] = v_89; + row[layout.auxiliaries + 90] = v_90; + switch (v_88) { + case 0ULL: { + const uint64_t v_91 = seed.word(92); + const uint64_t v_92 = seed.word(93); + const uint64_t v_93 = seed.word(94); + row[layout.auxiliaries + 91] = v_91; + row[layout.auxiliaries + 92] = v_92; + row[layout.auxiliaries + 93] = v_93; + switch (v_91) { + case 0ULL: { + const uint64_t v_94 = seed.word(95); + const uint64_t v_95 = seed.word(96); + const uint64_t v_96 = seed.word(97); + row[layout.auxiliaries + 94] = v_94; + row[layout.auxiliaries + 95] = v_95; + row[layout.auxiliaries + 96] = v_96; + switch (v_94) { + case 0ULL: { + const uint64_t v_97 = seed.word(98); + const uint64_t v_98 = seed.word(99); + const uint64_t v_99 = seed.word(100); + row[layout.auxiliaries + 97] = v_97; + row[layout.auxiliaries + 98] = v_98; + row[layout.auxiliaries + 99] = v_99; + switch (v_97) { + case 0ULL: { + const uint64_t v_100 = seed.word(101); + const uint64_t v_101 = seed.word(102); + const uint64_t v_102 = seed.word(103); + row[layout.auxiliaries + 100] = v_100; + row[layout.auxiliaries + 101] = v_101; + row[layout.auxiliaries + 102] = v_102; + switch (v_100) { + case 0ULL: { + const uint64_t v_103 = seed.word(104); + const uint64_t v_104 = seed.word(105); + const uint64_t v_105 = seed.word(106); + row[layout.auxiliaries + 103] = v_103; + row[layout.auxiliaries + 104] = v_104; + row[layout.auxiliaries + 105] = v_105; + switch (v_103) { + case 0ULL: { + const uint64_t v_106 = seed.word(107); + const uint64_t v_107 = seed.word(108); + const uint64_t v_108 = seed.word(109); + row[layout.auxiliaries + 106] = v_106; + row[layout.auxiliaries + 107] = v_107; + row[layout.auxiliaries + 108] = v_108; + switch (v_106) { + case 0ULL: { + const uint64_t v_109 = seed.word(110); + const uint64_t v_110 = seed.word(111); + const uint64_t v_111 = seed.word(112); + row[layout.auxiliaries + 109] = v_109; + row[layout.auxiliaries + 110] = v_110; + row[layout.auxiliaries + 111] = v_111; + switch (v_109) { + case 0ULL: { + const uint64_t v_112 = seed.word(113); + const uint64_t v_113 = seed.word(114); + const uint64_t v_114 = seed.word(115); + row[layout.auxiliaries + 112] = v_112; + row[layout.auxiliaries + 113] = v_113; + row[layout.auxiliaries + 114] = v_114; + switch (v_112) { + case 0ULL: { + const uint64_t v_115 = seed.word(116); + const uint64_t v_116 = seed.word(117); + const uint64_t v_117 = seed.word(118); + row[layout.auxiliaries + 115] = v_115; + row[layout.auxiliaries + 116] = v_116; + row[layout.auxiliaries + 117] = v_117; + switch (v_115) { + case 0ULL: { + const uint64_t v_118 = seed.word(119); + const uint64_t v_119 = seed.word(120); + const uint64_t v_120 = seed.word(121); + row[layout.auxiliaries + 118] = v_118; + row[layout.auxiliaries + 119] = v_119; + row[layout.auxiliaries + 120] = v_120; + switch (v_118) { + case 0ULL: { + const uint64_t v_121 = seed.word(122); + const uint64_t v_122 = seed.word(123); + const uint64_t v_123 = seed.word(124); + row[layout.auxiliaries + 121] = v_121; + row[layout.auxiliaries + 122] = v_122; + row[layout.auxiliaries + 123] = v_123; + switch (v_121) { + case 0ULL: { + const uint64_t v_124 = seed.word(125); + const uint64_t v_125 = seed.word(126); + const uint64_t v_126 = seed.word(127); + row[layout.auxiliaries + 124] = v_124; + row[layout.auxiliaries + 125] = v_125; + row[layout.auxiliaries + 126] = v_126; + switch (v_124) { + case 0ULL: { + const uint64_t v_127 = seed.word(128); + const uint64_t v_128 = seed.word(129); + const uint64_t v_129 = seed.word(130); + row[layout.auxiliaries + 127] = v_127; + row[layout.auxiliaries + 128] = v_128; + row[layout.auxiliaries + 129] = v_129; + switch (v_127) { + case 0ULL: { + const uint64_t v_130 = seed.word(131); + const uint64_t v_131 = seed.word(132); + const uint64_t v_132 = seed.word(133); + row[layout.auxiliaries + 130] = v_130; + row[layout.auxiliaries + 131] = v_131; + row[layout.auxiliaries + 132] = v_132; + switch (v_130) { + case 0ULL: { + const uint64_t v_133 = seed.word(134); + const uint64_t v_134 = seed.word(135); + const uint64_t v_135 = seed.word(136); + row[layout.auxiliaries + 133] = v_133; + row[layout.auxiliaries + 134] = v_134; + row[layout.auxiliaries + 135] = v_135; + switch (v_133) { + case 0ULL: { + const uint64_t v_136 = seed.word(137); + const uint64_t v_137 = seed.word(138); + const uint64_t v_138 = seed.word(139); + row[layout.auxiliaries + 136] = v_136; + row[layout.auxiliaries + 137] = v_137; + row[layout.auxiliaries + 138] = v_138; + switch (v_136) { + case 0ULL: { + const uint64_t v_139 = seed.word(140); + const uint64_t v_140 = seed.word(141); + const uint64_t v_141 = seed.word(142); + row[layout.auxiliaries + 139] = v_139; + row[layout.auxiliaries + 140] = v_140; + row[layout.auxiliaries + 141] = v_141; + switch (v_139) { + case 0ULL: { + const uint64_t v_142 = seed.word(143); + const uint64_t v_143 = seed.word(144); + const uint64_t v_144 = seed.word(145); + row[layout.auxiliaries + 142] = v_142; + row[layout.auxiliaries + 143] = v_143; + row[layout.auxiliaries + 144] = v_144; + switch (v_142) { + case 0ULL: { + const uint64_t v_145 = seed.word(146); + const uint64_t v_146 = seed.word(147); + const uint64_t v_147 = seed.word(148); + row[layout.auxiliaries + 145] = v_145; + row[layout.auxiliaries + 146] = v_146; + row[layout.auxiliaries + 147] = v_147; + switch (v_145) { + case 0ULL: { + const uint64_t v_148 = seed.word(149); + const uint64_t v_149 = seed.word(150); + const uint64_t v_150 = seed.word(151); + row[layout.auxiliaries + 148] = v_148; + row[layout.auxiliaries + 149] = v_149; + row[layout.auxiliaries + 150] = v_150; + switch (v_148) { + case 0ULL: { + const uint64_t v_151 = seed.word(152); + const uint64_t v_152 = seed.word(153); + const uint64_t v_153 = seed.word(154); + row[layout.auxiliaries + 151] = v_151; + row[layout.auxiliaries + 152] = v_152; + row[layout.auxiliaries + 153] = v_153; + switch (v_151) { + case 0ULL: { + const uint64_t v_154 = seed.word(155); + const uint64_t v_155 = seed.word(156); + const uint64_t v_156 = seed.word(157); + row[layout.auxiliaries + 154] = v_154; + row[layout.auxiliaries + 155] = v_155; + row[layout.auxiliaries + 156] = v_156; + switch (v_154) { + case 0ULL: { + const uint64_t v_157 = seed.word(158); + const uint64_t v_158 = seed.word(159); + const uint64_t v_159 = seed.word(160); + row[layout.auxiliaries + 157] = v_157; + row[layout.auxiliaries + 158] = v_158; + row[layout.auxiliaries + 159] = v_159; + switch (v_157) { + case 0ULL: { + const uint64_t v_160 = seed.word(161); + const uint64_t v_161 = seed.word(162); + const uint64_t v_162 = seed.word(163); + row[layout.auxiliaries + 160] = v_160; + row[layout.auxiliaries + 161] = v_161; + row[layout.auxiliaries + 162] = v_162; + switch (v_160) { + case 0ULL: { + const uint64_t v_163 = seed.word(164); + const uint64_t v_164 = seed.word(165); + const uint64_t v_165 = seed.word(166); + row[layout.auxiliaries + 163] = v_163; + row[layout.auxiliaries + 164] = v_164; + row[layout.auxiliaries + 165] = v_165; + switch (v_163) { + case 0ULL: { + const uint64_t v_166 = seed.word(167); + const uint64_t v_167 = seed.word(168); + const uint64_t v_168 = seed.word(169); + row[layout.auxiliaries + 166] = v_166; + row[layout.auxiliaries + 167] = v_167; + row[layout.auxiliaries + 168] = v_168; + switch (v_166) { + case 0ULL: { + const uint64_t v_169 = seed.word(170); + const uint64_t v_170 = seed.word(171); + const uint64_t v_171 = seed.word(172); + row[layout.auxiliaries + 169] = v_169; + row[layout.auxiliaries + 170] = v_170; + row[layout.auxiliaries + 171] = v_171; + switch (v_169) { + case 0ULL: { + const uint64_t v_172 = seed.word(173); + const uint64_t v_173 = seed.word(174); + const uint64_t v_174 = seed.word(175); + row[layout.auxiliaries + 172] = v_172; + row[layout.auxiliaries + 173] = v_173; + row[layout.auxiliaries + 174] = v_174; + switch (v_172) { + case 0ULL: { + const uint64_t v_175 = seed.word(176); + const uint64_t v_176 = seed.word(177); + const uint64_t v_177 = seed.word(178); + row[layout.auxiliaries + 175] = v_175; + row[layout.auxiliaries + 176] = v_176; + row[layout.auxiliaries + 177] = v_177; + switch (v_175) { + case 0ULL: { + const uint64_t v_178 = seed.word(179); + const uint64_t v_179 = seed.word(180); + const uint64_t v_180 = seed.word(181); + row[layout.auxiliaries + 178] = v_178; + row[layout.auxiliaries + 179] = v_179; + row[layout.auxiliaries + 180] = v_180; + switch (v_178) { + case 0ULL: { + const uint64_t v_181 = seed.word(182); + const uint64_t v_182 = seed.word(183); + const uint64_t v_183 = seed.word(184); + row[layout.auxiliaries + 181] = v_181; + row[layout.auxiliaries + 182] = v_182; + row[layout.auxiliaries + 183] = v_183; + switch (v_181) { + case 0ULL: { + const uint64_t v_184 = seed.word(185); + const uint64_t v_185 = seed.word(186); + const uint64_t v_186 = seed.word(187); + row[layout.auxiliaries + 184] = v_184; + row[layout.auxiliaries + 185] = v_185; + row[layout.auxiliaries + 186] = v_186; + switch (v_184) { + case 0ULL: { + const uint64_t v_187 = seed.word(188); + const uint64_t v_188 = seed.word(189); + const uint64_t v_189 = seed.word(190); + row[layout.auxiliaries + 187] = v_187; + row[layout.auxiliaries + 188] = v_188; + row[layout.auxiliaries + 189] = v_189; + switch (v_187) { + case 0ULL: { + const uint64_t v_190 = seed.word(191); + const uint64_t v_191 = seed.word(192); + const uint64_t v_192 = seed.word(193); + row[layout.auxiliaries + 190] = v_190; + row[layout.auxiliaries + 191] = v_191; + row[layout.auxiliaries + 192] = v_192; + switch (v_190) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_27(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 848 : 1552; + const Seed_ixvm_27 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_27(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_27(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_27<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_27<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_27(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 193) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 848 : encoding == 0 ? 1552 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_27); +} + +template struct Seed_ixvm_30 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 104); + case 5: return load_u32(data + 108); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 128); + case 8: return load_u8(data + 129); + case 9: return load_u8(data + 130); + case 10: return load_u8(data + 131); + case 11: return load_u8(data + 132); + case 12: return load_u8(data + 133); + case 13: return load_u8(data + 134); + case 14: return load_u8(data + 135); + case 15: return load_u8(data + 136); + case 16: return load_u8(data + 137); + case 17: return load_u8(data + 138); + case 18: return load_u8(data + 139); + case 19: return load_u8(data + 140); + case 20: return load_u8(data + 141); + case 21: return load_u8(data + 142); + case 22: return load_u8(data + 143); + case 23: return load_u8(data + 144); + case 24: return load_u8(data + 145); + case 25: return load_u8(data + 146); + case 26: return load_u8(data + 147); + case 27: return load_u8(data + 148); + case 28: return load_u8(data + 149); + case 29: return load_u8(data + 150); + case 30: return load_u8(data + 151); + case 31: return load_u8(data + 152); + case 32: return load_u8(data + 153); + case 33: return load_u8(data + 154); + case 34: return load_u8(data + 155); + case 35: return load_u8(data + 156); + case 36: return load_u8(data + 157); + case 37: return load_u8(data + 158); + case 38: return load_u8(data + 159); + case 39: return load_u8(data + 160); + case 40: return load_u8(data + 161); + case 41: return load_u8(data + 162); + case 42: return load_u8(data + 163); + case 43: return load_u8(data + 164); + case 44: return load_u8(data + 165); + case 45: return load_u8(data + 166); + case 46: return load_u8(data + 167); + case 47: return load_u8(data + 168); + case 48: return load_u8(data + 169); + case 49: return load_u8(data + 170); + case 50: return load_u8(data + 171); + case 51: return load_u8(data + 172); + case 52: return load_u8(data + 173); + case 53: return load_u8(data + 174); + case 54: return load_u8(data + 175); + case 55: return load_u8(data + 176); + case 56: return load_u8(data + 177); + case 57: return load_u8(data + 178); + case 58: return load_u8(data + 179); + case 59: return load_u8(data + 180); + case 60: return load_u8(data + 181); + case 61: return load_u8(data + 182); + case 62: return load_u8(data + 183); + case 63: return load_u8(data + 184); + case 64: return load_u8(data + 185); + case 65: return load_u8(data + 186); + case 66: return load_u8(data + 187); + case 67: return load_u8(data + 188); + case 68: return load_u8(data + 189); + case 69: return load_u8(data + 190); + case 70: return load_u8(data + 191); + case 71: return load_u8(data + 192); + case 72: return load_u8(data + 193); + case 73: return load_u8(data + 194); + case 74: return load_u8(data + 195); + case 75: return load_u8(data + 196); + case 76: return load_u8(data + 197); + case 77: return load_u8(data + 198); + case 78: return load_u8(data + 199); + case 79: return load_u8(data + 200); + case 80: return load_u8(data + 201); + case 81: return load_u8(data + 202); + case 82: return load_u8(data + 203); + case 83: return load_u8(data + 204); + case 84: return load_u8(data + 205); + case 85: return load_u8(data + 206); + case 86: return load_u8(data + 207); + case 87: return load_u8(data + 208); + case 88: return load_u8(data + 209); + case 89: return load_u8(data + 210); + case 90: return load_u8(data + 211); + case 91: return load_u8(data + 212); + case 92: return load_u8(data + 213); + case 93: return load_u8(data + 214); + case 94: return load_u8(data + 215); + case 95: return load_u8(data + 216); + case 96: return load_u8(data + 217); + case 97: return load_u8(data + 218); + case 98: return load_u8(data + 219); + case 99: return load_u8(data + 220); + case 100: return load_u8(data + 221); + case 101: return load_u8(data + 222); + case 102: return load_u8(data + 223); + case 103: return load_u8(data + 224); + case 104: return load_u8(data + 225); + case 105: return load_u8(data + 226); + case 106: return load_u8(data + 227); + case 107: return load_u8(data + 228); + case 108: return load_u8(data + 229); + case 109: return load_u8(data + 230); + case 110: return load_u8(data + 231); + case 111: return load_u8(data + 232); + case 112: return load_u8(data + 233); + case 113: return load_u8(data + 234); + case 114: return load_u8(data + 235); + case 115: return load_u8(data + 236); + case 116: return load_u8(data + 237); + case 117: return load_u8(data + 238); + case 118: return load_u8(data + 239); + case 119: return load_u8(data + 240); + case 120: return load_u8(data + 241); + case 121: return load_u8(data + 242); + case 122: return load_u8(data + 243); + case 123: return load_u8(data + 244); + case 124: return load_u8(data + 245); + case 125: return load_u8(data + 246); + case 126: return load_u8(data + 247); + case 127: return load_u8(data + 248); + case 128: return load_u8(data + 249); + case 129: return load_u8(data + 250); + case 130: return load_u8(data + 251); + case 131: return load_u8(data + 252); + case 132: return load_u8(data + 253); + case 133: return load_u8(data + 254); + case 134: return load_u8(data + 255); + case 135: return load_u8(data + 256); + case 136: return load_u8(data + 257); + case 137: return load_u8(data + 258); + case 138: return load_u8(data + 259); + case 139: return load_u8(data + 260); + case 140: return load_u8(data + 261); + case 141: return load_u8(data + 262); + case 142: return load_u8(data + 263); + case 143: return load_u8(data + 264); + case 144: return load_u8(data + 265); + case 145: return load_u32(data + 112); + case 146: return load_u32(data + 116); + case 147: return load_u64(data + 24); + case 148: return load_u64(data + 32); + case 149: return load_u64(data + 40); + case 150: return load_u64(data + 48); + case 151: return load_u64(data + 56); + case 152: return load_u64(data + 64); + case 153: return load_u64(data + 72); + case 154: return load_u64(data + 80); + case 155: return load_u32(data + 120); + case 156: return load_u32(data + 124); + case 157: return load_u64(data + 88); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_30(Seed_ixvm_30 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_8 = 8ULL; + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + const uint64_t v_44 = seed.word(42); + const uint64_t v_45 = seed.word(43); + const uint64_t v_46 = seed.word(44); + const uint64_t v_47 = seed.word(45); + const uint64_t v_48 = seed.word(46); + const uint64_t v_49 = seed.word(47); + const uint64_t v_50 = seed.word(48); + const uint64_t v_51 = seed.word(49); + const uint64_t v_52 = seed.word(50); + const uint64_t v_53 = seed.word(51); + const uint64_t v_54 = seed.word(52); + const uint64_t v_55 = seed.word(53); + const uint64_t v_56 = seed.word(54); + const uint64_t v_57 = seed.word(55); + const uint64_t v_58 = seed.word(56); + const uint64_t v_59 = seed.word(57); + const uint64_t v_60 = seed.word(58); + const uint64_t v_61 = seed.word(59); + const uint64_t v_62 = seed.word(60); + const uint64_t v_63 = seed.word(61); + const uint64_t v_64 = seed.word(62); + const uint64_t v_65 = seed.word(63); + const uint64_t v_66 = seed.word(64); + const uint64_t v_67 = seed.word(65); + const uint64_t v_68 = seed.word(66); + const uint64_t v_69 = seed.word(67); + const uint64_t v_70 = seed.word(68); + const uint64_t v_71 = seed.word(69); + const uint64_t v_72 = seed.word(70); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.auxiliaries + 26] = v_34; + row[layout.auxiliaries + 27] = v_35; + row[layout.auxiliaries + 28] = v_36; + row[layout.auxiliaries + 29] = v_37; + row[layout.auxiliaries + 30] = v_38; + row[layout.auxiliaries + 31] = v_39; + row[layout.auxiliaries + 32] = v_40; + row[layout.auxiliaries + 33] = v_41; + row[layout.auxiliaries + 34] = v_42; + row[layout.auxiliaries + 35] = v_43; + row[layout.auxiliaries + 36] = v_44; + row[layout.auxiliaries + 37] = v_45; + row[layout.auxiliaries + 38] = v_46; + row[layout.auxiliaries + 39] = v_47; + row[layout.auxiliaries + 40] = v_48; + row[layout.auxiliaries + 41] = v_49; + row[layout.auxiliaries + 42] = v_50; + row[layout.auxiliaries + 43] = v_51; + row[layout.auxiliaries + 44] = v_52; + row[layout.auxiliaries + 45] = v_53; + row[layout.auxiliaries + 46] = v_54; + row[layout.auxiliaries + 47] = v_55; + row[layout.auxiliaries + 48] = v_56; + row[layout.auxiliaries + 49] = v_57; + row[layout.auxiliaries + 50] = v_58; + row[layout.auxiliaries + 51] = v_59; + row[layout.auxiliaries + 52] = v_60; + row[layout.auxiliaries + 53] = v_61; + row[layout.auxiliaries + 54] = v_62; + row[layout.auxiliaries + 55] = v_63; + row[layout.auxiliaries + 56] = v_64; + row[layout.auxiliaries + 57] = v_65; + row[layout.auxiliaries + 58] = v_66; + row[layout.auxiliaries + 59] = v_67; + row[layout.auxiliaries + 60] = v_68; + row[layout.auxiliaries + 61] = v_69; + row[layout.auxiliaries + 62] = v_70; + row[layout.auxiliaries + 63] = v_71; + row[layout.auxiliaries + 64] = v_72; + switch (v_2) { + case 1023ULL: { + const uint64_t v_73 = seed.word(71); + row[layout.auxiliaries + 65] = v_73; + const uint64_t v_74 = seed.word(72); + const uint64_t v_75 = seed.word(73); + const uint64_t v_76 = seed.word(74); + const uint64_t v_77 = seed.word(75); + const uint64_t v_78 = seed.word(76); + const uint64_t v_79 = seed.word(77); + const uint64_t v_80 = seed.word(78); + const uint64_t v_81 = seed.word(79); + row[layout.auxiliaries + 66] = v_74; + row[layout.auxiliaries + 67] = v_75; + row[layout.auxiliaries + 68] = v_76; + row[layout.auxiliaries + 69] = v_77; + row[layout.auxiliaries + 70] = v_78; + row[layout.auxiliaries + 71] = v_79; + row[layout.auxiliaries + 72] = v_80; + row[layout.auxiliaries + 73] = v_81; + const uint64_t v_82 = seed.word(80); + row[layout.auxiliaries + 74] = v_82; + const uint64_t v_83 = goldilocks_mul(v_73, v_82); + row[layout.auxiliaries + 75] = v_83; + const uint64_t v_117 = seed.word(81); + const uint64_t v_118 = seed.word(82); + const uint64_t v_119 = seed.word(83); + const uint64_t v_120 = seed.word(84); + const uint64_t v_121 = seed.word(85); + const uint64_t v_122 = seed.word(86); + const uint64_t v_123 = seed.word(87); + const uint64_t v_124 = seed.word(88); + const uint64_t v_125 = seed.word(89); + const uint64_t v_126 = seed.word(90); + const uint64_t v_127 = seed.word(91); + const uint64_t v_128 = seed.word(92); + const uint64_t v_129 = seed.word(93); + const uint64_t v_130 = seed.word(94); + const uint64_t v_131 = seed.word(95); + const uint64_t v_132 = seed.word(96); + const uint64_t v_133 = seed.word(97); + const uint64_t v_134 = seed.word(98); + const uint64_t v_135 = seed.word(99); + const uint64_t v_136 = seed.word(100); + const uint64_t v_137 = seed.word(101); + const uint64_t v_138 = seed.word(102); + const uint64_t v_139 = seed.word(103); + const uint64_t v_140 = seed.word(104); + const uint64_t v_141 = seed.word(105); + const uint64_t v_142 = seed.word(106); + const uint64_t v_143 = seed.word(107); + const uint64_t v_144 = seed.word(108); + const uint64_t v_145 = seed.word(109); + const uint64_t v_146 = seed.word(110); + const uint64_t v_147 = seed.word(111); + const uint64_t v_148 = seed.word(112); + row[layout.auxiliaries + 76] = v_117; + row[layout.auxiliaries + 77] = v_118; + row[layout.auxiliaries + 78] = v_119; + row[layout.auxiliaries + 79] = v_120; + row[layout.auxiliaries + 80] = v_121; + row[layout.auxiliaries + 81] = v_122; + row[layout.auxiliaries + 82] = v_123; + row[layout.auxiliaries + 83] = v_124; + row[layout.auxiliaries + 84] = v_125; + row[layout.auxiliaries + 85] = v_126; + row[layout.auxiliaries + 86] = v_127; + row[layout.auxiliaries + 87] = v_128; + row[layout.auxiliaries + 88] = v_129; + row[layout.auxiliaries + 89] = v_130; + row[layout.auxiliaries + 90] = v_131; + row[layout.auxiliaries + 91] = v_132; + row[layout.auxiliaries + 92] = v_133; + row[layout.auxiliaries + 93] = v_134; + row[layout.auxiliaries + 94] = v_135; + row[layout.auxiliaries + 95] = v_136; + row[layout.auxiliaries + 96] = v_137; + row[layout.auxiliaries + 97] = v_138; + row[layout.auxiliaries + 98] = v_139; + row[layout.auxiliaries + 99] = v_140; + row[layout.auxiliaries + 100] = v_141; + row[layout.auxiliaries + 101] = v_142; + row[layout.auxiliaries + 102] = v_143; + row[layout.auxiliaries + 103] = v_144; + row[layout.auxiliaries + 104] = v_145; + row[layout.auxiliaries + 105] = v_146; + row[layout.auxiliaries + 106] = v_147; + row[layout.auxiliaries + 107] = v_148; + const uint64_t v_151 = seed.word(113); + const uint64_t v_152 = seed.word(114); + const uint64_t v_153 = seed.word(115); + const uint64_t v_154 = seed.word(116); + const uint64_t v_155 = seed.word(117); + const uint64_t v_156 = seed.word(118); + const uint64_t v_157 = seed.word(119); + const uint64_t v_158 = seed.word(120); + const uint64_t v_159 = seed.word(121); + const uint64_t v_160 = seed.word(122); + const uint64_t v_161 = seed.word(123); + const uint64_t v_162 = seed.word(124); + const uint64_t v_163 = seed.word(125); + const uint64_t v_164 = seed.word(126); + const uint64_t v_165 = seed.word(127); + const uint64_t v_166 = seed.word(128); + const uint64_t v_167 = seed.word(129); + const uint64_t v_168 = seed.word(130); + const uint64_t v_169 = seed.word(131); + const uint64_t v_170 = seed.word(132); + const uint64_t v_171 = seed.word(133); + const uint64_t v_172 = seed.word(134); + const uint64_t v_173 = seed.word(135); + const uint64_t v_174 = seed.word(136); + const uint64_t v_175 = seed.word(137); + const uint64_t v_176 = seed.word(138); + const uint64_t v_177 = seed.word(139); + const uint64_t v_178 = seed.word(140); + const uint64_t v_179 = seed.word(141); + const uint64_t v_180 = seed.word(142); + const uint64_t v_181 = seed.word(143); + const uint64_t v_182 = seed.word(144); + row[layout.auxiliaries + 108] = v_151; + row[layout.auxiliaries + 109] = v_152; + row[layout.auxiliaries + 110] = v_153; + row[layout.auxiliaries + 111] = v_154; + row[layout.auxiliaries + 112] = v_155; + row[layout.auxiliaries + 113] = v_156; + row[layout.auxiliaries + 114] = v_157; + row[layout.auxiliaries + 115] = v_158; + row[layout.auxiliaries + 116] = v_159; + row[layout.auxiliaries + 117] = v_160; + row[layout.auxiliaries + 118] = v_161; + row[layout.auxiliaries + 119] = v_162; + row[layout.auxiliaries + 120] = v_163; + row[layout.auxiliaries + 121] = v_164; + row[layout.auxiliaries + 122] = v_165; + row[layout.auxiliaries + 123] = v_166; + row[layout.auxiliaries + 124] = v_167; + row[layout.auxiliaries + 125] = v_168; + row[layout.auxiliaries + 126] = v_169; + row[layout.auxiliaries + 127] = v_170; + row[layout.auxiliaries + 128] = v_171; + row[layout.auxiliaries + 129] = v_172; + row[layout.auxiliaries + 130] = v_173; + row[layout.auxiliaries + 131] = v_174; + row[layout.auxiliaries + 132] = v_175; + row[layout.auxiliaries + 133] = v_176; + row[layout.auxiliaries + 134] = v_177; + row[layout.auxiliaries + 135] = v_178; + row[layout.auxiliaries + 136] = v_179; + row[layout.auxiliaries + 137] = v_180; + row[layout.auxiliaries + 138] = v_181; + row[layout.auxiliaries + 139] = v_182; + const uint64_t v_183 = seed.word(145); + row[layout.auxiliaries + 140] = v_183; + const uint64_t v_185 = seed.word(146); + row[layout.auxiliaries + 141] = v_185; + const uint64_t v_186 = seed.word(147); + const uint64_t v_187 = seed.word(148); + const uint64_t v_188 = seed.word(149); + const uint64_t v_189 = seed.word(150); + const uint64_t v_190 = seed.word(151); + const uint64_t v_191 = seed.word(152); + const uint64_t v_192 = seed.word(153); + const uint64_t v_193 = seed.word(154); + row[layout.auxiliaries + 142] = v_186; + row[layout.auxiliaries + 143] = v_187; + row[layout.auxiliaries + 144] = v_188; + row[layout.auxiliaries + 145] = v_189; + row[layout.auxiliaries + 146] = v_190; + row[layout.auxiliaries + 147] = v_191; + row[layout.auxiliaries + 148] = v_192; + row[layout.auxiliaries + 149] = v_193; + const uint64_t v_194 = seed.word(155); + row[layout.auxiliaries + 150] = v_194; + const uint64_t v_195 = seed.word(156); + row[layout.auxiliaries + 151] = v_195; + const uint64_t v_196 = seed.word(157); + row[layout.auxiliaries + 152] = v_196; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 65] = inverse(goldilocks_sub(v_2, 1023ULL)); + const uint64_t v_197 = seed.word(71); + row[layout.auxiliaries + 66] = v_197; + const uint64_t v_199 = seed.word(72); + row[layout.auxiliaries + 67] = v_199; + const uint64_t v_200 = seed.word(73); + const uint64_t v_201 = seed.word(74); + const uint64_t v_202 = seed.word(75); + const uint64_t v_203 = seed.word(76); + const uint64_t v_204 = seed.word(77); + const uint64_t v_205 = seed.word(78); + const uint64_t v_206 = seed.word(79); + const uint64_t v_207 = seed.word(80); + row[layout.auxiliaries + 68] = v_200; + row[layout.auxiliaries + 69] = v_201; + row[layout.auxiliaries + 70] = v_202; + row[layout.auxiliaries + 71] = v_203; + row[layout.auxiliaries + 72] = v_204; + row[layout.auxiliaries + 73] = v_205; + row[layout.auxiliaries + 74] = v_206; + row[layout.auxiliaries + 75] = v_207; + const uint64_t v_208 = seed.word(81); + row[layout.auxiliaries + 76] = v_208; + const uint64_t v_209 = goldilocks_mul(v_208, v_8); + const uint64_t v_210 = goldilocks_mul(v_199, v_209); + row[layout.auxiliaries + 77] = v_210; + const uint64_t v_211 = 63ULL; + const uint64_t v_212 = goldilocks_sub(v_2, v_211); + const uint64_t v_213 = uint64_t(v_212 == 0); + row[layout.auxiliaries + 78] = inverse(v_212); + row[layout.auxiliaries + 79] = v_213; + const uint64_t v_217 = seed.word(82); + const uint64_t v_218 = seed.word(83); + const uint64_t v_219 = seed.word(84); + const uint64_t v_220 = seed.word(85); + const uint64_t v_221 = seed.word(86); + const uint64_t v_222 = seed.word(87); + const uint64_t v_223 = seed.word(88); + const uint64_t v_224 = seed.word(89); + const uint64_t v_225 = seed.word(90); + const uint64_t v_226 = seed.word(91); + const uint64_t v_227 = seed.word(92); + const uint64_t v_228 = seed.word(93); + const uint64_t v_229 = seed.word(94); + const uint64_t v_230 = seed.word(95); + const uint64_t v_231 = seed.word(96); + const uint64_t v_232 = seed.word(97); + const uint64_t v_233 = seed.word(98); + const uint64_t v_234 = seed.word(99); + const uint64_t v_235 = seed.word(100); + const uint64_t v_236 = seed.word(101); + const uint64_t v_237 = seed.word(102); + const uint64_t v_238 = seed.word(103); + const uint64_t v_239 = seed.word(104); + const uint64_t v_240 = seed.word(105); + const uint64_t v_241 = seed.word(106); + const uint64_t v_242 = seed.word(107); + const uint64_t v_243 = seed.word(108); + const uint64_t v_244 = seed.word(109); + const uint64_t v_245 = seed.word(110); + const uint64_t v_246 = seed.word(111); + const uint64_t v_247 = seed.word(112); + const uint64_t v_248 = seed.word(113); + row[layout.auxiliaries + 80] = v_217; + row[layout.auxiliaries + 81] = v_218; + row[layout.auxiliaries + 82] = v_219; + row[layout.auxiliaries + 83] = v_220; + row[layout.auxiliaries + 84] = v_221; + row[layout.auxiliaries + 85] = v_222; + row[layout.auxiliaries + 86] = v_223; + row[layout.auxiliaries + 87] = v_224; + row[layout.auxiliaries + 88] = v_225; + row[layout.auxiliaries + 89] = v_226; + row[layout.auxiliaries + 90] = v_227; + row[layout.auxiliaries + 91] = v_228; + row[layout.auxiliaries + 92] = v_229; + row[layout.auxiliaries + 93] = v_230; + row[layout.auxiliaries + 94] = v_231; + row[layout.auxiliaries + 95] = v_232; + row[layout.auxiliaries + 96] = v_233; + row[layout.auxiliaries + 97] = v_234; + row[layout.auxiliaries + 98] = v_235; + row[layout.auxiliaries + 99] = v_236; + row[layout.auxiliaries + 100] = v_237; + row[layout.auxiliaries + 101] = v_238; + row[layout.auxiliaries + 102] = v_239; + row[layout.auxiliaries + 103] = v_240; + row[layout.auxiliaries + 104] = v_241; + row[layout.auxiliaries + 105] = v_242; + row[layout.auxiliaries + 106] = v_243; + row[layout.auxiliaries + 107] = v_244; + row[layout.auxiliaries + 108] = v_245; + row[layout.auxiliaries + 109] = v_246; + row[layout.auxiliaries + 110] = v_247; + row[layout.auxiliaries + 111] = v_248; + const uint64_t v_266 = seed.word(114); + const uint64_t v_267 = seed.word(115); + const uint64_t v_268 = seed.word(116); + const uint64_t v_269 = seed.word(117); + const uint64_t v_270 = seed.word(118); + const uint64_t v_271 = seed.word(119); + const uint64_t v_272 = seed.word(120); + const uint64_t v_273 = seed.word(121); + const uint64_t v_274 = seed.word(122); + const uint64_t v_275 = seed.word(123); + const uint64_t v_276 = seed.word(124); + const uint64_t v_277 = seed.word(125); + const uint64_t v_278 = seed.word(126); + const uint64_t v_279 = seed.word(127); + const uint64_t v_280 = seed.word(128); + const uint64_t v_281 = seed.word(129); + const uint64_t v_282 = seed.word(130); + const uint64_t v_283 = seed.word(131); + const uint64_t v_284 = seed.word(132); + const uint64_t v_285 = seed.word(133); + const uint64_t v_286 = seed.word(134); + const uint64_t v_287 = seed.word(135); + const uint64_t v_288 = seed.word(136); + const uint64_t v_289 = seed.word(137); + const uint64_t v_290 = seed.word(138); + const uint64_t v_291 = seed.word(139); + const uint64_t v_292 = seed.word(140); + const uint64_t v_293 = seed.word(141); + const uint64_t v_294 = seed.word(142); + const uint64_t v_295 = seed.word(143); + const uint64_t v_296 = seed.word(144); + const uint64_t v_297 = seed.word(145); + row[layout.auxiliaries + 112] = v_266; + row[layout.auxiliaries + 113] = v_267; + row[layout.auxiliaries + 114] = v_268; + row[layout.auxiliaries + 115] = v_269; + row[layout.auxiliaries + 116] = v_270; + row[layout.auxiliaries + 117] = v_271; + row[layout.auxiliaries + 118] = v_272; + row[layout.auxiliaries + 119] = v_273; + row[layout.auxiliaries + 120] = v_274; + row[layout.auxiliaries + 121] = v_275; + row[layout.auxiliaries + 122] = v_276; + row[layout.auxiliaries + 123] = v_277; + row[layout.auxiliaries + 124] = v_278; + row[layout.auxiliaries + 125] = v_279; + row[layout.auxiliaries + 126] = v_280; + row[layout.auxiliaries + 127] = v_281; + row[layout.auxiliaries + 128] = v_282; + row[layout.auxiliaries + 129] = v_283; + row[layout.auxiliaries + 130] = v_284; + row[layout.auxiliaries + 131] = v_285; + row[layout.auxiliaries + 132] = v_286; + row[layout.auxiliaries + 133] = v_287; + row[layout.auxiliaries + 134] = v_288; + row[layout.auxiliaries + 135] = v_289; + row[layout.auxiliaries + 136] = v_290; + row[layout.auxiliaries + 137] = v_291; + row[layout.auxiliaries + 138] = v_292; + row[layout.auxiliaries + 139] = v_293; + row[layout.auxiliaries + 140] = v_294; + row[layout.auxiliaries + 141] = v_295; + row[layout.auxiliaries + 142] = v_296; + row[layout.auxiliaries + 143] = v_297; + const uint64_t v_299 = seed.word(146); + row[layout.auxiliaries + 144] = v_299; + const uint64_t v_301 = seed.word(147); + row[layout.auxiliaries + 145] = v_301; + const uint64_t v_302 = seed.word(148); + row[layout.auxiliaries + 146] = v_302; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_30(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 272 : 1264; + const Seed_ixvm_30 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_30(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_30(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_30<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_30<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_30(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 153) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 272 : encoding == 0 ? 1264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_30); +} + +__device__ __constant__ uint64_t inverse_34_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_34 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_34(Seed_ixvm_34 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_34_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_34(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_ixvm_34 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_34(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_34(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_34<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_34<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_34(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_34); +} + +__device__ __constant__ uint64_t inverse_38_0[] = {0ULL}; +template struct Seed_ixvm_38 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 28); + case 3: return load_u8(data + 29); + case 4: return load_u8(data + 30); + case 5: return load_u8(data + 31); + case 6: return load_u8(data + 32); + case 7: return load_u8(data + 33); + case 8: return load_u8(data + 34); + case 9: return load_u8(data + 35); + case 10: return load_u64(data + 16); + case 11: return load_u32(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_38(Seed_ixvm_38 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = goldilocks_add(v_7, v_8); + const uint64_t v_11 = goldilocks_add(v_6, v_10); + const uint64_t v_12 = goldilocks_add(v_5, v_11); + const uint64_t v_13 = goldilocks_add(v_4, v_12); + const uint64_t v_14 = goldilocks_add(v_3, v_13); + const uint64_t v_15 = goldilocks_add(v_2, v_14); + switch (v_15) { + case 0ULL: { + const uint64_t v_16 = 32ULL; + if (v_1 > 255 || v_16 > 255) return 1; + const uint64_t v_17 = uint64_t(v_1 < v_16); + row[layout.auxiliaries + 1] = v_17; + switch (v_17) { + case 1ULL: { + const uint64_t v_22 = seed.word(11); + row[layout.auxiliaries + 2] = v_22; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_26 = seed.word(11); + row[layout.auxiliaries + 2] = v_26; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_15 <= 0ULL ? inverse_38_0[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); + const uint64_t v_30 = seed.word(11); + row[layout.auxiliaries + 2] = v_30; + row[layout.selectors + 2] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_38(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 96; + const Seed_ixvm_38 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_38(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_38(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_38<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_38<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_38(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 10 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 96 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_38); +} + +template struct Seed_ixvm_40 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u8(data + 40); + case 4: return load_u8(data + 41); + case 5: return load_u8(data + 42); + case 6: return load_u8(data + 43); + case 7: return load_u8(data + 44); + case 8: return load_u8(data + 45); + case 9: return load_u8(data + 46); + case 10: return load_u8(data + 47); + case 11: return load_u64(data + 24); + case 12: return load_u8(data + 48); + case 13: return load_u8(data + 49); + case 14: return load_u8(data + 50); + case 15: return load_u8(data + 51); + case 16: return load_u8(data + 52); + case 17: return load_u8(data + 53); + case 18: return load_u8(data + 54); + case 19: return load_u8(data + 55); + case 20: return load_u8(data + 56); + case 21: return load_u32(data + 32); + case 22: return load_u32(data + 36); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_40(Seed_ixvm_40 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_17 = seed.word(12); + const uint64_t v_18 = seed.word(13); + const uint64_t v_19 = seed.word(14); + const uint64_t v_20 = seed.word(15); + const uint64_t v_21 = seed.word(16); + const uint64_t v_22 = seed.word(17); + const uint64_t v_23 = seed.word(18); + const uint64_t v_24 = seed.word(19); + const uint64_t v_25 = seed.word(20); + row[layout.auxiliaries + 1] = v_17; + row[layout.auxiliaries + 2] = v_18; + row[layout.auxiliaries + 3] = v_19; + row[layout.auxiliaries + 4] = v_20; + row[layout.auxiliaries + 5] = v_21; + row[layout.auxiliaries + 6] = v_22; + row[layout.auxiliaries + 7] = v_23; + row[layout.auxiliaries + 8] = v_24; + row[layout.auxiliaries + 9] = v_25; + switch (v_25) { + case 0ULL: { + const uint64_t v_26 = 256ULL; + const uint64_t v_27 = 2ULL; + const uint64_t v_28 = goldilocks_mul(v_27, v_1); + const uint64_t v_29 = goldilocks_sub(v_26, v_28); + if (v_2 > 255 || v_29 > 255) return 1; + const uint64_t v_30 = ((v_2 + v_29) & 255ULL); + const uint64_t v_31 = ((v_2 + v_29) >> 8); + row[layout.auxiliaries + 10] = v_30; + const uint64_t v_38 = seed.word(21); + row[layout.auxiliaries + 11] = v_38; + const uint64_t v_39 = seed.word(22); + row[layout.auxiliaries + 12] = v_39; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_44 = seed.word(21); + row[layout.auxiliaries + 10] = v_44; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_40(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 184; + const Seed_ixvm_40 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_40(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_40(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_40<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_40<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_40(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 11 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 13) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 184 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_40); +} + +__device__ __constant__ uint64_t inverse_41_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_41_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_41_2[] = {0ULL}; +template struct Seed_ixvm_41 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 40); + case 3: return load_u8(data + 41); + case 4: return load_u8(data + 42); + case 5: return load_u8(data + 43); + case 6: return load_u8(data + 44); + case 7: return load_u8(data + 45); + case 8: return load_u8(data + 46); + case 9: return load_u8(data + 47); + case 10: return load_u8(data + 48); + case 11: return load_u64(data + 16); + case 12: return load_u64(data + 24); + case 13: return load_u32(data + 32); + case 14: return load_u8(data + 49); + case 15: return load_u8(data + 50); + case 16: return load_u8(data + 51); + case 17: return load_u8(data + 52); + case 18: return load_u8(data + 53); + case 19: return load_u8(data + 54); + case 20: return load_u8(data + 55); + case 21: return load_u32(data + 36); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_41(Seed_ixvm_41 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + switch (v_1) { + case 0ULL: { + const uint64_t v_11 = goldilocks_add(v_8, v_9); + const uint64_t v_12 = goldilocks_add(v_7, v_11); + const uint64_t v_13 = goldilocks_add(v_6, v_12); + const uint64_t v_14 = goldilocks_add(v_5, v_13); + const uint64_t v_15 = goldilocks_add(v_4, v_14); + switch (v_15) { + case 0ULL: { + const uint64_t v_18 = seed.word(12); + row[layout.auxiliaries + 1] = v_18; + const uint64_t v_19 = seed.word(13); + row[layout.auxiliaries + 2] = v_19; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_15 <= 0ULL ? inverse_41_0[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); + const uint64_t v_22 = seed.word(12); + const uint64_t v_23 = seed.word(13); + const uint64_t v_24 = seed.word(14); + const uint64_t v_25 = seed.word(15); + const uint64_t v_26 = seed.word(16); + const uint64_t v_27 = seed.word(17); + const uint64_t v_28 = seed.word(18); + const uint64_t v_29 = seed.word(19); + const uint64_t v_30 = seed.word(20); + row[layout.auxiliaries + 2] = v_22; + row[layout.auxiliaries + 3] = v_23; + row[layout.auxiliaries + 4] = v_24; + row[layout.auxiliaries + 5] = v_25; + row[layout.auxiliaries + 6] = v_26; + row[layout.auxiliaries + 7] = v_27; + row[layout.auxiliaries + 8] = v_28; + row[layout.auxiliaries + 9] = v_29; + row[layout.auxiliaries + 10] = v_30; + const uint64_t v_32 = seed.word(21); + row[layout.auxiliaries + 11] = v_32; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + case 1ULL: { + const uint64_t v_33 = goldilocks_add(v_8, v_9); + const uint64_t v_34 = goldilocks_add(v_7, v_33); + const uint64_t v_35 = goldilocks_add(v_6, v_34); + const uint64_t v_36 = goldilocks_add(v_5, v_35); + switch (v_36) { + case 0ULL: { + const uint64_t v_41 = seed.word(12); + row[layout.auxiliaries + 1] = v_41; + const uint64_t v_42 = seed.word(13); + row[layout.auxiliaries + 2] = v_42; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_36 <= 0ULL ? inverse_41_1[v_36] : inverse(goldilocks_sub(v_36, 0ULL))); + const uint64_t v_45 = seed.word(12); + const uint64_t v_46 = seed.word(13); + const uint64_t v_47 = seed.word(14); + const uint64_t v_48 = seed.word(15); + const uint64_t v_49 = seed.word(16); + const uint64_t v_50 = seed.word(17); + const uint64_t v_51 = seed.word(18); + const uint64_t v_52 = seed.word(19); + const uint64_t v_53 = seed.word(20); + row[layout.auxiliaries + 2] = v_45; + row[layout.auxiliaries + 3] = v_46; + row[layout.auxiliaries + 4] = v_47; + row[layout.auxiliaries + 5] = v_48; + row[layout.auxiliaries + 6] = v_49; + row[layout.auxiliaries + 7] = v_50; + row[layout.auxiliaries + 8] = v_51; + row[layout.auxiliaries + 9] = v_52; + row[layout.auxiliaries + 10] = v_53; + const uint64_t v_55 = seed.word(21); + row[layout.auxiliaries + 11] = v_55; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + case 2ULL: { + const uint64_t v_56 = goldilocks_add(v_8, v_9); + const uint64_t v_57 = goldilocks_add(v_7, v_56); + const uint64_t v_58 = goldilocks_add(v_6, v_57); + switch (v_58) { + case 0ULL: { + const uint64_t v_63 = seed.word(12); + row[layout.auxiliaries + 1] = v_63; + const uint64_t v_64 = seed.word(13); + row[layout.auxiliaries + 2] = v_64; + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_58 <= 0ULL ? inverse_41_2[v_58] : inverse(goldilocks_sub(v_58, 0ULL))); + const uint64_t v_67 = seed.word(12); + const uint64_t v_68 = seed.word(13); + const uint64_t v_69 = seed.word(14); + const uint64_t v_70 = seed.word(15); + const uint64_t v_71 = seed.word(16); + const uint64_t v_72 = seed.word(17); + const uint64_t v_73 = seed.word(18); + const uint64_t v_74 = seed.word(19); + const uint64_t v_75 = seed.word(20); + row[layout.auxiliaries + 2] = v_67; + row[layout.auxiliaries + 3] = v_68; + row[layout.auxiliaries + 4] = v_69; + row[layout.auxiliaries + 5] = v_70; + row[layout.auxiliaries + 6] = v_71; + row[layout.auxiliaries + 7] = v_72; + row[layout.auxiliaries + 8] = v_73; + row[layout.auxiliaries + 9] = v_74; + row[layout.auxiliaries + 10] = v_75; + const uint64_t v_77 = seed.word(21); + row[layout.auxiliaries + 11] = v_77; + row[layout.selectors + 5] = 1; + return 0; + } + } + } + case 3ULL: { + const uint64_t v_82 = seed.word(12); + row[layout.auxiliaries + 1] = v_82; + const uint64_t v_83 = seed.word(13); + row[layout.auxiliaries + 2] = v_83; + row[layout.selectors + 6] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_41(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 176; + const Seed_ixvm_41 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_41(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_41(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_41<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_41<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_41(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 11 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 12) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 176 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_41); +} + +template struct Seed_ixvm_44 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_44(Seed_ixvm_44 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + switch (v_0) { + default: { + uint64_t v_7; + switch (v_0) { + case 0ULL: { + const uint64_t v_3 = 0ULL; + row[layout.selectors + 0] = 1; + v_7 = v_3; + goto continuation_0; + } + case 1ULL: { + const uint64_t v_4 = 1ULL; + row[layout.selectors + 1] = 1; + v_7 = v_4; + goto continuation_0; + } + case 2ULL: { + const uint64_t v_5 = 2ULL; + row[layout.selectors + 2] = 1; + v_7 = v_5; + goto continuation_0; + } + case 3ULL: { + const uint64_t v_6 = 3ULL; + row[layout.selectors + 3] = 1; + v_7 = v_6; + goto continuation_0; + } + default: { + return 2; + } + } + continuation_0:; + row[layout.auxiliaries + 1] = v_7; + const uint64_t v_9 = seed.word(4); + row[layout.auxiliaries + 2] = v_9; + row[layout.selectors + 4] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_44(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 16 : 40; + const Seed_ixvm_44 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_44(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_44(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_44<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_44<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_44(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 16 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_44); +} + +__device__ __constant__ uint64_t inverse_47_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_47 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 336); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u64(data + 80); + case 12: return load_u64(data + 88); + case 13: return load_u64(data + 96); + case 14: return load_u64(data + 104); + case 15: return load_u64(data + 112); + case 16: return load_u64(data + 120); + case 17: return load_u64(data + 128); + case 18: return load_u64(data + 136); + case 19: return load_u8(data + 348); + case 20: return load_u32(data + 340); + case 21: return load_u64(data + 144); + case 22: return load_u8(data + 349); + case 23: return load_u64(data + 152); + case 24: return load_u64(data + 160); + case 25: return load_u64(data + 168); + case 26: return load_u64(data + 176); + case 27: return load_u64(data + 184); + case 28: return load_u32(data + 344); + case 29: return load_u64(data + 192); + case 30: return load_u8(data + 350); + case 31: return load_u8(data + 351); + case 32: return load_u8(data + 352); + case 33: return load_u8(data + 353); + case 34: return load_u8(data + 354); + case 35: return load_u8(data + 355); + case 36: return load_u64(data + 200); + case 37: return load_u64(data + 208); + case 38: return load_u64(data + 216); + case 39: return load_u64(data + 224); + case 40: return load_u64(data + 232); + case 41: return load_u64(data + 240); + case 42: return load_u64(data + 248); + case 43: return load_u64(data + 256); + case 44: return load_u64(data + 264); + case 45: return load_u64(data + 272); + case 46: return load_u64(data + 280); + case 47: return load_u64(data + 288); + case 48: return load_u64(data + 296); + case 49: return load_u64(data + 304); + case 50: return load_u64(data + 312); + case 51: return load_u64(data + 320); + case 52: return load_u64(data + 328); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_47(Seed_ixvm_47 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + switch (v_0) { + case 7ULL: { + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + row[layout.auxiliaries + 1] = v_18; + row[layout.auxiliaries + 2] = v_19; + row[layout.auxiliaries + 3] = v_20; + row[layout.auxiliaries + 4] = v_21; + row[layout.auxiliaries + 5] = v_22; + row[layout.auxiliaries + 6] = v_23; + row[layout.auxiliaries + 7] = v_24; + row[layout.auxiliaries + 8] = v_25; + row[layout.auxiliaries + 9] = v_26; + row[layout.auxiliaries + 10] = v_27; + row[layout.auxiliaries + 11] = v_28; + row[layout.auxiliaries + 12] = v_29; + row[layout.auxiliaries + 13] = v_30; + row[layout.auxiliaries + 14] = v_31; + row[layout.auxiliaries + 15] = v_32; + row[layout.auxiliaries + 16] = v_33; + row[layout.auxiliaries + 17] = v_34; + row[layout.auxiliaries + 18] = v_35; + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + row[layout.auxiliaries + 19] = v_36; + row[layout.auxiliaries + 20] = v_37; + row[layout.auxiliaries + 21] = v_38; + row[layout.auxiliaries + 22] = v_39; + row[layout.auxiliaries + 23] = v_40; + row[layout.auxiliaries + 24] = v_41; + row[layout.auxiliaries + 25] = v_42; + row[layout.auxiliaries + 26] = v_43; + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 27] = v_44; + row[layout.auxiliaries + 28] = v_45; + row[layout.auxiliaries + 29] = v_46; + row[layout.auxiliaries + 30] = v_47; + row[layout.auxiliaries + 31] = v_48; + row[layout.auxiliaries + 32] = v_49; + row[layout.auxiliaries + 33] = v_50; + row[layout.auxiliaries + 34] = v_51; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_47_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_47(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 360 : 424; + const Seed_ixvm_47 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_47(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_47(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_47<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_47<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_47(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 18 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 360 : encoding == 0 ? 424 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_47); +} + +__device__ __constant__ uint64_t inverse_48_0[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_48 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u32(data + 336); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u64(data + 80); + case 12: return load_u64(data + 88); + case 13: return load_u64(data + 96); + case 14: return load_u64(data + 104); + case 15: return load_u64(data + 112); + case 16: return load_u64(data + 120); + case 17: return load_u64(data + 128); + case 18: return load_u64(data + 136); + case 19: return load_u8(data + 348); + case 20: return load_u64(data + 144); + case 21: return load_u64(data + 152); + case 22: return load_u8(data + 349); + case 23: return load_u64(data + 160); + case 24: return load_u32(data + 340); + case 25: return load_u64(data + 168); + case 26: return load_u64(data + 176); + case 27: return load_u64(data + 184); + case 28: return load_u32(data + 344); + case 29: return load_u64(data + 192); + case 30: return load_u8(data + 350); + case 31: return load_u8(data + 351); + case 32: return load_u8(data + 352); + case 33: return load_u8(data + 353); + case 34: return load_u8(data + 354); + case 35: return load_u8(data + 355); + case 36: return load_u64(data + 200); + case 37: return load_u64(data + 208); + case 38: return load_u64(data + 216); + case 39: return load_u64(data + 224); + case 40: return load_u64(data + 232); + case 41: return load_u64(data + 240); + case 42: return load_u64(data + 248); + case 43: return load_u64(data + 256); + case 44: return load_u64(data + 264); + case 45: return load_u64(data + 272); + case 46: return load_u64(data + 280); + case 47: return load_u64(data + 288); + case 48: return load_u64(data + 296); + case 49: return load_u64(data + 304); + case 50: return load_u64(data + 312); + case 51: return load_u64(data + 320); + case 52: return load_u64(data + 328); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_48(Seed_ixvm_48 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + switch (v_0) { + case 8ULL: { + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + row[layout.auxiliaries + 1] = v_18; + row[layout.auxiliaries + 2] = v_19; + row[layout.auxiliaries + 3] = v_20; + row[layout.auxiliaries + 4] = v_21; + row[layout.auxiliaries + 5] = v_22; + row[layout.auxiliaries + 6] = v_23; + row[layout.auxiliaries + 7] = v_24; + row[layout.auxiliaries + 8] = v_25; + row[layout.auxiliaries + 9] = v_26; + row[layout.auxiliaries + 10] = v_27; + row[layout.auxiliaries + 11] = v_28; + row[layout.auxiliaries + 12] = v_29; + row[layout.auxiliaries + 13] = v_30; + row[layout.auxiliaries + 14] = v_31; + row[layout.auxiliaries + 15] = v_32; + row[layout.auxiliaries + 16] = v_33; + row[layout.auxiliaries + 17] = v_34; + row[layout.auxiliaries + 18] = v_35; + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + row[layout.auxiliaries + 19] = v_36; + row[layout.auxiliaries + 20] = v_37; + row[layout.auxiliaries + 21] = v_38; + row[layout.auxiliaries + 22] = v_39; + row[layout.auxiliaries + 23] = v_40; + row[layout.auxiliaries + 24] = v_41; + row[layout.auxiliaries + 25] = v_42; + row[layout.auxiliaries + 26] = v_43; + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 27] = v_44; + row[layout.auxiliaries + 28] = v_45; + row[layout.auxiliaries + 29] = v_46; + row[layout.auxiliaries + 30] = v_47; + row[layout.auxiliaries + 31] = v_48; + row[layout.auxiliaries + 32] = v_49; + row[layout.auxiliaries + 33] = v_50; + row[layout.auxiliaries + 34] = v_51; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 8ULL ? inverse_48_0[v_0] : inverse(goldilocks_sub(v_0, 8ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_48(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 360 : 424; + const Seed_ixvm_48 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_48(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_48(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_48<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_48<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_48(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 18 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 360 : encoding == 0 ? 424 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_48); +} + +__device__ __constant__ uint64_t inverse_49_0[] = {14347467609544676694ULL, 2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_49 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u32(data + 336); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u64(data + 80); + case 12: return load_u64(data + 88); + case 13: return load_u64(data + 96); + case 14: return load_u64(data + 104); + case 15: return load_u64(data + 112); + case 16: return load_u64(data + 120); + case 17: return load_u64(data + 128); + case 18: return load_u64(data + 136); + case 19: return load_u8(data + 348); + case 20: return load_u64(data + 144); + case 21: return load_u64(data + 152); + case 22: return load_u8(data + 349); + case 23: return load_u64(data + 160); + case 24: return load_u64(data + 168); + case 25: return load_u64(data + 176); + case 26: return load_u32(data + 340); + case 27: return load_u64(data + 184); + case 28: return load_u32(data + 344); + case 29: return load_u64(data + 192); + case 30: return load_u8(data + 350); + case 31: return load_u8(data + 351); + case 32: return load_u8(data + 352); + case 33: return load_u8(data + 353); + case 34: return load_u8(data + 354); + case 35: return load_u8(data + 355); + case 36: return load_u64(data + 200); + case 37: return load_u64(data + 208); + case 38: return load_u64(data + 216); + case 39: return load_u64(data + 224); + case 40: return load_u64(data + 232); + case 41: return load_u64(data + 240); + case 42: return load_u64(data + 248); + case 43: return load_u64(data + 256); + case 44: return load_u64(data + 264); + case 45: return load_u64(data + 272); + case 46: return load_u64(data + 280); + case 47: return load_u64(data + 288); + case 48: return load_u64(data + 296); + case 49: return load_u64(data + 304); + case 50: return load_u64(data + 312); + case 51: return load_u64(data + 320); + case 52: return load_u64(data + 328); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_49(Seed_ixvm_49 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + switch (v_0) { + case 9ULL: { + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + row[layout.auxiliaries + 1] = v_18; + row[layout.auxiliaries + 2] = v_19; + row[layout.auxiliaries + 3] = v_20; + row[layout.auxiliaries + 4] = v_21; + row[layout.auxiliaries + 5] = v_22; + row[layout.auxiliaries + 6] = v_23; + row[layout.auxiliaries + 7] = v_24; + row[layout.auxiliaries + 8] = v_25; + row[layout.auxiliaries + 9] = v_26; + row[layout.auxiliaries + 10] = v_27; + row[layout.auxiliaries + 11] = v_28; + row[layout.auxiliaries + 12] = v_29; + row[layout.auxiliaries + 13] = v_30; + row[layout.auxiliaries + 14] = v_31; + row[layout.auxiliaries + 15] = v_32; + row[layout.auxiliaries + 16] = v_33; + row[layout.auxiliaries + 17] = v_34; + row[layout.auxiliaries + 18] = v_35; + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + row[layout.auxiliaries + 19] = v_36; + row[layout.auxiliaries + 20] = v_37; + row[layout.auxiliaries + 21] = v_38; + row[layout.auxiliaries + 22] = v_39; + row[layout.auxiliaries + 23] = v_40; + row[layout.auxiliaries + 24] = v_41; + row[layout.auxiliaries + 25] = v_42; + row[layout.auxiliaries + 26] = v_43; + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 27] = v_44; + row[layout.auxiliaries + 28] = v_45; + row[layout.auxiliaries + 29] = v_46; + row[layout.auxiliaries + 30] = v_47; + row[layout.auxiliaries + 31] = v_48; + row[layout.auxiliaries + 32] = v_49; + row[layout.auxiliaries + 33] = v_50; + row[layout.auxiliaries + 34] = v_51; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 9ULL ? inverse_49_0[v_0] : inverse(goldilocks_sub(v_0, 9ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_49(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 360 : 424; + const Seed_ixvm_49 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_49(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_49(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_49<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_49<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_49(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 18 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 360 : encoding == 0 ? 424 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_49); +} + +__device__ __constant__ uint64_t inverse_50_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_50 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 40); + case 2: return load_u8(data + 41); + case 3: return load_u8(data + 42); + case 4: return load_u8(data + 43); + case 5: return load_u8(data + 44); + case 6: return load_u8(data + 45); + case 7: return load_u8(data + 46); + case 8: return load_u8(data + 47); + case 9: return load_u8(data + 48); + case 10: return load_u8(data + 49); + case 11: return load_u8(data + 50); + case 12: return load_u8(data + 51); + case 13: return load_u8(data + 52); + case 14: return load_u8(data + 53); + case 15: return load_u8(data + 54); + case 16: return load_u8(data + 55); + case 17: return load_u8(data + 56); + case 18: return load_u32(data + 16); + case 19: return load_u64(data + 8); + case 20: return load_u32(data + 20); + case 21: return load_u8(data + 57); + case 22: return load_u8(data + 58); + case 23: return load_u8(data + 59); + case 24: return load_u8(data + 60); + case 25: return load_u8(data + 61); + case 26: return load_u8(data + 62); + case 27: return load_u8(data + 63); + case 28: return load_u8(data + 64); + case 29: return load_u8(data + 65); + case 30: return load_u8(data + 66); + case 31: return load_u8(data + 67); + case 32: return load_u8(data + 68); + case 33: return load_u8(data + 69); + case 34: return load_u8(data + 70); + case 35: return load_u8(data + 71); + case 36: return load_u8(data + 72); + case 37: return load_u32(data + 24); + case 38: return load_u8(data + 73); + case 39: return load_u8(data + 74); + case 40: return load_u8(data + 75); + case 41: return load_u8(data + 76); + case 42: return load_u8(data + 77); + case 43: return load_u8(data + 78); + case 44: return load_u8(data + 79); + case 45: return load_u8(data + 80); + case 46: return load_u8(data + 81); + case 47: return load_u8(data + 82); + case 48: return load_u8(data + 83); + case 49: return load_u8(data + 84); + case 50: return load_u8(data + 85); + case 51: return load_u8(data + 86); + case 52: return load_u8(data + 87); + case 53: return load_u8(data + 88); + case 54: return load_u8(data + 89); + case 55: return load_u32(data + 28); + case 56: return load_u32(data + 32); + case 57: return load_u32(data + 36); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_50(Seed_ixvm_50 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + switch (v_0) { + case 7ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 1] = v_19; + row[layout.auxiliaries + 2] = v_20; + row[layout.auxiliaries + 3] = v_21; + row[layout.auxiliaries + 4] = v_22; + row[layout.auxiliaries + 5] = v_23; + row[layout.auxiliaries + 6] = v_24; + row[layout.auxiliaries + 7] = v_25; + row[layout.auxiliaries + 8] = v_26; + row[layout.auxiliaries + 9] = v_27; + row[layout.auxiliaries + 10] = v_28; + row[layout.auxiliaries + 11] = v_29; + row[layout.auxiliaries + 12] = v_30; + row[layout.auxiliaries + 13] = v_31; + row[layout.auxiliaries + 14] = v_32; + row[layout.auxiliaries + 15] = v_33; + row[layout.auxiliaries + 16] = v_34; + row[layout.auxiliaries + 17] = v_35; + row[layout.auxiliaries + 18] = v_36; + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 19] = v_37; + row[layout.auxiliaries + 20] = v_38; + row[layout.auxiliaries + 21] = v_39; + row[layout.auxiliaries + 22] = v_40; + row[layout.auxiliaries + 23] = v_41; + row[layout.auxiliaries + 24] = v_42; + row[layout.auxiliaries + 25] = v_43; + row[layout.auxiliaries + 26] = v_44; + row[layout.auxiliaries + 27] = v_45; + row[layout.auxiliaries + 28] = v_46; + row[layout.auxiliaries + 29] = v_47; + row[layout.auxiliaries + 30] = v_48; + row[layout.auxiliaries + 31] = v_49; + row[layout.auxiliaries + 32] = v_50; + row[layout.auxiliaries + 33] = v_51; + row[layout.auxiliaries + 34] = v_52; + row[layout.auxiliaries + 35] = v_53; + row[layout.auxiliaries + 36] = v_54; + const uint64_t v_55 = seed.word(56); + row[layout.auxiliaries + 37] = v_55; + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 38] = v_56; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_50_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const uint64_t v_57 = seed.word(20); + row[layout.auxiliaries + 2] = v_57; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_50(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 96 : 464; + const Seed_ixvm_50 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_50(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_50(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_50<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_50<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_50(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 19 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 39) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 464 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_50); +} + +__device__ __constant__ uint64_t inverse_51_0[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_51 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 44); + case 2: return load_u8(data + 45); + case 3: return load_u8(data + 46); + case 4: return load_u8(data + 47); + case 5: return load_u8(data + 48); + case 6: return load_u8(data + 49); + case 7: return load_u8(data + 50); + case 8: return load_u8(data + 51); + case 9: return load_u8(data + 52); + case 10: return load_u8(data + 53); + case 11: return load_u8(data + 54); + case 12: return load_u8(data + 55); + case 13: return load_u8(data + 56); + case 14: return load_u8(data + 57); + case 15: return load_u8(data + 58); + case 16: return load_u8(data + 59); + case 17: return load_u8(data + 60); + case 18: return load_u32(data + 16); + case 19: return load_u64(data + 8); + case 20: return load_u32(data + 20); + case 21: return load_u8(data + 61); + case 22: return load_u8(data + 62); + case 23: return load_u8(data + 63); + case 24: return load_u8(data + 64); + case 25: return load_u8(data + 65); + case 26: return load_u8(data + 66); + case 27: return load_u8(data + 67); + case 28: return load_u8(data + 68); + case 29: return load_u8(data + 69); + case 30: return load_u8(data + 70); + case 31: return load_u8(data + 71); + case 32: return load_u8(data + 72); + case 33: return load_u8(data + 73); + case 34: return load_u8(data + 74); + case 35: return load_u8(data + 75); + case 36: return load_u8(data + 76); + case 37: return load_u32(data + 24); + case 38: return load_u8(data + 77); + case 39: return load_u8(data + 78); + case 40: return load_u8(data + 79); + case 41: return load_u8(data + 80); + case 42: return load_u8(data + 81); + case 43: return load_u8(data + 82); + case 44: return load_u8(data + 83); + case 45: return load_u8(data + 84); + case 46: return load_u8(data + 85); + case 47: return load_u8(data + 86); + case 48: return load_u8(data + 87); + case 49: return load_u8(data + 88); + case 50: return load_u8(data + 89); + case 51: return load_u8(data + 90); + case 52: return load_u8(data + 91); + case 53: return load_u8(data + 92); + case 54: return load_u8(data + 93); + case 55: return load_u32(data + 28); + case 56: return load_u32(data + 32); + case 57: return load_u32(data + 36); + case 58: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_51(Seed_ixvm_51 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + switch (v_0) { + case 8ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 1] = v_19; + row[layout.auxiliaries + 2] = v_20; + row[layout.auxiliaries + 3] = v_21; + row[layout.auxiliaries + 4] = v_22; + row[layout.auxiliaries + 5] = v_23; + row[layout.auxiliaries + 6] = v_24; + row[layout.auxiliaries + 7] = v_25; + row[layout.auxiliaries + 8] = v_26; + row[layout.auxiliaries + 9] = v_27; + row[layout.auxiliaries + 10] = v_28; + row[layout.auxiliaries + 11] = v_29; + row[layout.auxiliaries + 12] = v_30; + row[layout.auxiliaries + 13] = v_31; + row[layout.auxiliaries + 14] = v_32; + row[layout.auxiliaries + 15] = v_33; + row[layout.auxiliaries + 16] = v_34; + row[layout.auxiliaries + 17] = v_35; + row[layout.auxiliaries + 18] = v_36; + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 19] = v_37; + row[layout.auxiliaries + 20] = v_38; + row[layout.auxiliaries + 21] = v_39; + row[layout.auxiliaries + 22] = v_40; + row[layout.auxiliaries + 23] = v_41; + row[layout.auxiliaries + 24] = v_42; + row[layout.auxiliaries + 25] = v_43; + row[layout.auxiliaries + 26] = v_44; + row[layout.auxiliaries + 27] = v_45; + row[layout.auxiliaries + 28] = v_46; + row[layout.auxiliaries + 29] = v_47; + row[layout.auxiliaries + 30] = v_48; + row[layout.auxiliaries + 31] = v_49; + row[layout.auxiliaries + 32] = v_50; + row[layout.auxiliaries + 33] = v_51; + row[layout.auxiliaries + 34] = v_52; + row[layout.auxiliaries + 35] = v_53; + row[layout.auxiliaries + 36] = v_54; + const uint64_t v_55 = seed.word(56); + row[layout.auxiliaries + 37] = v_55; + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 38] = v_56; + const uint64_t v_57 = seed.word(58); + row[layout.auxiliaries + 39] = v_57; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 8ULL ? inverse_51_0[v_0] : inverse(goldilocks_sub(v_0, 8ULL))); + const uint64_t v_58 = seed.word(20); + row[layout.auxiliaries + 2] = v_58; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_51(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 96 : 472; + const Seed_ixvm_51 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_51(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_51(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_51<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_51<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_51(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 19 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 40) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 472 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_51); +} + +__device__ __constant__ uint64_t inverse_52_0[] = {14347467609544676694ULL, 2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_52 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 44); + case 2: return load_u8(data + 45); + case 3: return load_u8(data + 46); + case 4: return load_u8(data + 47); + case 5: return load_u8(data + 48); + case 6: return load_u8(data + 49); + case 7: return load_u8(data + 50); + case 8: return load_u8(data + 51); + case 9: return load_u8(data + 52); + case 10: return load_u8(data + 53); + case 11: return load_u8(data + 54); + case 12: return load_u8(data + 55); + case 13: return load_u8(data + 56); + case 14: return load_u8(data + 57); + case 15: return load_u8(data + 58); + case 16: return load_u8(data + 59); + case 17: return load_u8(data + 60); + case 18: return load_u32(data + 16); + case 19: return load_u64(data + 8); + case 20: return load_u32(data + 20); + case 21: return load_u8(data + 61); + case 22: return load_u8(data + 62); + case 23: return load_u8(data + 63); + case 24: return load_u8(data + 64); + case 25: return load_u8(data + 65); + case 26: return load_u8(data + 66); + case 27: return load_u8(data + 67); + case 28: return load_u8(data + 68); + case 29: return load_u8(data + 69); + case 30: return load_u8(data + 70); + case 31: return load_u8(data + 71); + case 32: return load_u8(data + 72); + case 33: return load_u8(data + 73); + case 34: return load_u8(data + 74); + case 35: return load_u8(data + 75); + case 36: return load_u8(data + 76); + case 37: return load_u32(data + 24); + case 38: return load_u8(data + 77); + case 39: return load_u8(data + 78); + case 40: return load_u8(data + 79); + case 41: return load_u8(data + 80); + case 42: return load_u8(data + 81); + case 43: return load_u8(data + 82); + case 44: return load_u8(data + 83); + case 45: return load_u8(data + 84); + case 46: return load_u8(data + 85); + case 47: return load_u8(data + 86); + case 48: return load_u8(data + 87); + case 49: return load_u8(data + 88); + case 50: return load_u8(data + 89); + case 51: return load_u8(data + 90); + case 52: return load_u8(data + 91); + case 53: return load_u8(data + 92); + case 54: return load_u8(data + 93); + case 55: return load_u32(data + 28); + case 56: return load_u32(data + 32); + case 57: return load_u32(data + 36); + case 58: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_52(Seed_ixvm_52 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + switch (v_0) { + case 9ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 1] = v_19; + row[layout.auxiliaries + 2] = v_20; + row[layout.auxiliaries + 3] = v_21; + row[layout.auxiliaries + 4] = v_22; + row[layout.auxiliaries + 5] = v_23; + row[layout.auxiliaries + 6] = v_24; + row[layout.auxiliaries + 7] = v_25; + row[layout.auxiliaries + 8] = v_26; + row[layout.auxiliaries + 9] = v_27; + row[layout.auxiliaries + 10] = v_28; + row[layout.auxiliaries + 11] = v_29; + row[layout.auxiliaries + 12] = v_30; + row[layout.auxiliaries + 13] = v_31; + row[layout.auxiliaries + 14] = v_32; + row[layout.auxiliaries + 15] = v_33; + row[layout.auxiliaries + 16] = v_34; + row[layout.auxiliaries + 17] = v_35; + row[layout.auxiliaries + 18] = v_36; + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 19] = v_37; + row[layout.auxiliaries + 20] = v_38; + row[layout.auxiliaries + 21] = v_39; + row[layout.auxiliaries + 22] = v_40; + row[layout.auxiliaries + 23] = v_41; + row[layout.auxiliaries + 24] = v_42; + row[layout.auxiliaries + 25] = v_43; + row[layout.auxiliaries + 26] = v_44; + row[layout.auxiliaries + 27] = v_45; + row[layout.auxiliaries + 28] = v_46; + row[layout.auxiliaries + 29] = v_47; + row[layout.auxiliaries + 30] = v_48; + row[layout.auxiliaries + 31] = v_49; + row[layout.auxiliaries + 32] = v_50; + row[layout.auxiliaries + 33] = v_51; + row[layout.auxiliaries + 34] = v_52; + row[layout.auxiliaries + 35] = v_53; + row[layout.auxiliaries + 36] = v_54; + const uint64_t v_55 = seed.word(56); + row[layout.auxiliaries + 37] = v_55; + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 38] = v_56; + const uint64_t v_57 = seed.word(58); + row[layout.auxiliaries + 39] = v_57; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 9ULL ? inverse_52_0[v_0] : inverse(goldilocks_sub(v_0, 9ULL))); + const uint64_t v_58 = seed.word(20); + row[layout.auxiliaries + 2] = v_58; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_52(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 96 : 472; + const Seed_ixvm_52 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_52(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_52(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_52<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_52<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_52(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 19 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 40) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 472 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_52); +} + +__device__ __constant__ uint64_t inverse_55_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_55 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 264); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u32(data + 268); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u64(data + 96); + case 15: return load_u64(data + 104); + case 16: return load_u64(data + 112); + case 17: return load_u64(data + 120); + case 18: return load_u64(data + 128); + case 19: return load_u64(data + 136); + case 20: return load_u64(data + 144); + case 21: return load_u64(data + 152); + case 22: return load_u64(data + 160); + case 23: return load_u64(data + 168); + case 24: return load_u64(data + 176); + case 25: return load_u64(data + 184); + case 26: return load_u64(data + 192); + case 27: return load_u64(data + 200); + case 28: return load_u64(data + 208); + case 29: return load_u64(data + 216); + case 30: return load_u64(data + 224); + case 31: return load_u64(data + 232); + case 32: return load_u64(data + 240); + case 33: return load_u64(data + 248); + case 34: return load_u64(data + 256); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_55(Seed_ixvm_55 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + switch (v_0) { + case 1ULL: { + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_55_0[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_55(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 272 : 280; + const Seed_ixvm_55 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_55(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_55(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_55<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_55<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_55(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 9 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 26) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 272 : encoding == 0 ? 280 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_55); +} + +__device__ __constant__ uint64_t inverse_56_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_56 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 208); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u32(data + 212); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u64(data + 96); + case 15: return load_u64(data + 104); + case 16: return load_u64(data + 112); + case 17: return load_u64(data + 120); + case 18: return load_u64(data + 128); + case 19: return load_u64(data + 136); + case 20: return load_u64(data + 144); + case 21: return load_u64(data + 152); + case 22: return load_u64(data + 160); + case 23: return load_u64(data + 168); + case 24: return load_u64(data + 176); + case 25: return load_u64(data + 184); + case 26: return load_u64(data + 192); + case 27: return load_u64(data + 200); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_56(Seed_ixvm_56 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + switch (v_0) { + case 1ULL: { + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_56_0[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_56(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 216 : 224; + const Seed_ixvm_56 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_56(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_56(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_56<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_56<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_56(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 9 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 19) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 216 : encoding == 0 ? 224 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_56); +} + +template struct Seed_ixvm_57 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 36); + case 2: return load_u8(data + 37); + case 3: return load_u8(data + 38); + case 4: return load_u8(data + 39); + case 5: return load_u8(data + 40); + case 6: return load_u8(data + 41); + case 7: return load_u8(data + 42); + case 8: return load_u8(data + 43); + case 9: return load_u8(data + 44); + case 10: return load_u64(data + 8); + case 11: return load_u32(data + 16); + case 12: return load_u8(data + 45); + case 13: return load_u8(data + 46); + case 14: return load_u8(data + 47); + case 15: return load_u8(data + 48); + case 16: return load_u8(data + 49); + case 17: return load_u8(data + 50); + case 18: return load_u8(data + 51); + case 19: return load_u8(data + 52); + case 20: return load_u8(data + 53); + case 21: return load_u8(data + 54); + case 22: return load_u8(data + 55); + case 23: return load_u8(data + 56); + case 24: return load_u8(data + 57); + case 25: return load_u8(data + 58); + case 26: return load_u8(data + 59); + case 27: return load_u8(data + 60); + case 28: return load_u32(data + 20); + case 29: return load_u32(data + 24); + case 30: return load_u32(data + 28); + case 31: return load_u32(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_57(Seed_ixvm_57 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + switch (v_0) { + case 0ULL: { + const uint64_t v_11 = seed.word(11); + row[layout.auxiliaries + 1] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_12 = seed.word(11); + const uint64_t v_13 = seed.word(12); + const uint64_t v_14 = seed.word(13); + const uint64_t v_15 = seed.word(14); + const uint64_t v_16 = seed.word(15); + const uint64_t v_17 = seed.word(16); + const uint64_t v_18 = seed.word(17); + const uint64_t v_19 = seed.word(18); + row[layout.auxiliaries + 1] = v_12; + row[layout.auxiliaries + 2] = v_13; + row[layout.auxiliaries + 3] = v_14; + row[layout.auxiliaries + 4] = v_15; + row[layout.auxiliaries + 5] = v_16; + row[layout.auxiliaries + 6] = v_17; + row[layout.auxiliaries + 7] = v_18; + row[layout.auxiliaries + 8] = v_19; + const uint64_t v_20 = seed.word(19); + const uint64_t v_21 = seed.word(20); + const uint64_t v_22 = seed.word(21); + const uint64_t v_23 = seed.word(22); + const uint64_t v_24 = seed.word(23); + const uint64_t v_25 = seed.word(24); + const uint64_t v_26 = seed.word(25); + const uint64_t v_27 = seed.word(26); + const uint64_t v_28 = seed.word(27); + row[layout.auxiliaries + 9] = v_20; + row[layout.auxiliaries + 10] = v_21; + row[layout.auxiliaries + 11] = v_22; + row[layout.auxiliaries + 12] = v_23; + row[layout.auxiliaries + 13] = v_24; + row[layout.auxiliaries + 14] = v_25; + row[layout.auxiliaries + 15] = v_26; + row[layout.auxiliaries + 16] = v_27; + row[layout.auxiliaries + 17] = v_28; + const uint64_t v_30 = seed.word(28); + row[layout.auxiliaries + 18] = v_30; + const uint64_t v_31 = seed.word(29); + row[layout.auxiliaries + 19] = v_31; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_32 = seed.word(11); + const uint64_t v_33 = seed.word(12); + const uint64_t v_34 = seed.word(13); + const uint64_t v_35 = seed.word(14); + const uint64_t v_36 = seed.word(15); + const uint64_t v_37 = seed.word(16); + const uint64_t v_38 = seed.word(17); + const uint64_t v_39 = seed.word(18); + const uint64_t v_40 = seed.word(19); + row[layout.auxiliaries + 1] = v_32; + row[layout.auxiliaries + 2] = v_33; + row[layout.auxiliaries + 3] = v_34; + row[layout.auxiliaries + 4] = v_35; + row[layout.auxiliaries + 5] = v_36; + row[layout.auxiliaries + 6] = v_37; + row[layout.auxiliaries + 7] = v_38; + row[layout.auxiliaries + 8] = v_39; + row[layout.auxiliaries + 9] = v_40; + const uint64_t v_41 = seed.word(20); + const uint64_t v_42 = seed.word(21); + const uint64_t v_43 = seed.word(22); + const uint64_t v_44 = seed.word(23); + const uint64_t v_45 = seed.word(24); + const uint64_t v_46 = seed.word(25); + const uint64_t v_47 = seed.word(26); + const uint64_t v_48 = seed.word(27); + const uint64_t v_49 = seed.word(28); + row[layout.auxiliaries + 10] = v_41; + row[layout.auxiliaries + 11] = v_42; + row[layout.auxiliaries + 12] = v_43; + row[layout.auxiliaries + 13] = v_44; + row[layout.auxiliaries + 14] = v_45; + row[layout.auxiliaries + 15] = v_46; + row[layout.auxiliaries + 16] = v_47; + row[layout.auxiliaries + 17] = v_48; + row[layout.auxiliaries + 18] = v_49; + const uint64_t v_52 = seed.word(29); + row[layout.auxiliaries + 19] = v_52; + const uint64_t v_53 = seed.word(30); + row[layout.auxiliaries + 20] = v_53; + const uint64_t v_54 = seed.word(31); + row[layout.auxiliaries + 21] = v_54; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_55 = seed.word(11); + const uint64_t v_56 = seed.word(12); + const uint64_t v_57 = seed.word(13); + const uint64_t v_58 = seed.word(14); + const uint64_t v_59 = seed.word(15); + const uint64_t v_60 = seed.word(16); + const uint64_t v_61 = seed.word(17); + const uint64_t v_62 = seed.word(18); + const uint64_t v_63 = seed.word(19); + row[layout.auxiliaries + 1] = v_55; + row[layout.auxiliaries + 2] = v_56; + row[layout.auxiliaries + 3] = v_57; + row[layout.auxiliaries + 4] = v_58; + row[layout.auxiliaries + 5] = v_59; + row[layout.auxiliaries + 6] = v_60; + row[layout.auxiliaries + 7] = v_61; + row[layout.auxiliaries + 8] = v_62; + row[layout.auxiliaries + 9] = v_63; + const uint64_t v_64 = seed.word(20); + const uint64_t v_65 = seed.word(21); + const uint64_t v_66 = seed.word(22); + const uint64_t v_67 = seed.word(23); + const uint64_t v_68 = seed.word(24); + const uint64_t v_69 = seed.word(25); + const uint64_t v_70 = seed.word(26); + const uint64_t v_71 = seed.word(27); + const uint64_t v_72 = seed.word(28); + row[layout.auxiliaries + 10] = v_64; + row[layout.auxiliaries + 11] = v_65; + row[layout.auxiliaries + 12] = v_66; + row[layout.auxiliaries + 13] = v_67; + row[layout.auxiliaries + 14] = v_68; + row[layout.auxiliaries + 15] = v_69; + row[layout.auxiliaries + 16] = v_70; + row[layout.auxiliaries + 17] = v_71; + row[layout.auxiliaries + 18] = v_72; + const uint64_t v_75 = seed.word(29); + row[layout.auxiliaries + 19] = v_75; + const uint64_t v_76 = seed.word(30); + row[layout.auxiliaries + 20] = v_76; + const uint64_t v_77 = seed.word(31); + row[layout.auxiliaries + 21] = v_77; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_79 = seed.word(11); + row[layout.auxiliaries + 1] = v_79; + row[layout.selectors + 4] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_57(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 256; + const Seed_ixvm_57 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_57(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_57(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_57<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_57<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_57(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 10 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 256 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_57); +} + +template struct Seed_ixvm_62 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 48); + case 2: return load_u8(data + 49); + case 3: return load_u8(data + 50); + case 4: return load_u8(data + 51); + case 5: return load_u8(data + 52); + case 6: return load_u8(data + 53); + case 7: return load_u8(data + 54); + case 8: return load_u8(data + 55); + case 9: return load_u8(data + 56); + case 10: return load_u8(data + 57); + case 11: return load_u32(data + 16); + case 12: return load_u32(data + 20); + case 13: return load_u64(data + 8); + case 14: return load_u8(data + 58); + case 15: return load_u8(data + 59); + case 16: return load_u8(data + 60); + case 17: return load_u8(data + 61); + case 18: return load_u8(data + 62); + case 19: return load_u8(data + 63); + case 20: return load_u8(data + 64); + case 21: return load_u8(data + 65); + case 22: return load_u8(data + 66); + case 23: return load_u8(data + 67); + case 24: return load_u8(data + 68); + case 25: return load_u8(data + 69); + case 26: return load_u8(data + 70); + case 27: return load_u8(data + 71); + case 28: return load_u8(data + 72); + case 29: return load_u8(data + 73); + case 30: return load_u8(data + 74); + case 31: return load_u32(data + 24); + case 32: return load_u8(data + 75); + case 33: return load_u8(data + 76); + case 34: return load_u8(data + 77); + case 35: return load_u8(data + 78); + case 36: return load_u8(data + 79); + case 37: return load_u8(data + 80); + case 38: return load_u8(data + 81); + case 39: return load_u8(data + 82); + case 40: return load_u8(data + 83); + case 41: return load_u8(data + 84); + case 42: return load_u8(data + 85); + case 43: return load_u8(data + 86); + case 44: return load_u8(data + 87); + case 45: return load_u8(data + 88); + case 46: return load_u8(data + 89); + case 47: return load_u8(data + 90); + case 48: return load_u8(data + 91); + case 49: return load_u32(data + 28); + case 50: return load_u8(data + 92); + case 51: return load_u32(data + 32); + case 52: return load_u32(data + 36); + case 53: return load_u32(data + 40); + case 54: return load_u32(data + 44); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_62(Seed_ixvm_62 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + switch (v_0) { + default: { + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 1] = v_13; + row[layout.auxiliaries + 2] = v_14; + row[layout.auxiliaries + 3] = v_15; + row[layout.auxiliaries + 4] = v_16; + row[layout.auxiliaries + 5] = v_17; + row[layout.auxiliaries + 6] = v_18; + row[layout.auxiliaries + 7] = v_19; + row[layout.auxiliaries + 8] = v_20; + row[layout.auxiliaries + 9] = v_21; + row[layout.auxiliaries + 10] = v_22; + row[layout.auxiliaries + 11] = v_23; + row[layout.auxiliaries + 12] = v_24; + row[layout.auxiliaries + 13] = v_25; + row[layout.auxiliaries + 14] = v_26; + row[layout.auxiliaries + 15] = v_27; + row[layout.auxiliaries + 16] = v_28; + row[layout.auxiliaries + 17] = v_29; + row[layout.auxiliaries + 18] = v_30; + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 19] = v_31; + row[layout.auxiliaries + 20] = v_32; + row[layout.auxiliaries + 21] = v_33; + row[layout.auxiliaries + 22] = v_34; + row[layout.auxiliaries + 23] = v_35; + row[layout.auxiliaries + 24] = v_36; + row[layout.auxiliaries + 25] = v_37; + row[layout.auxiliaries + 26] = v_38; + row[layout.auxiliaries + 27] = v_39; + row[layout.auxiliaries + 28] = v_40; + row[layout.auxiliaries + 29] = v_41; + row[layout.auxiliaries + 30] = v_42; + row[layout.auxiliaries + 31] = v_43; + row[layout.auxiliaries + 32] = v_44; + row[layout.auxiliaries + 33] = v_45; + row[layout.auxiliaries + 34] = v_46; + row[layout.auxiliaries + 35] = v_47; + row[layout.auxiliaries + 36] = v_48; + const uint64_t v_49 = seed.word(50); + row[layout.auxiliaries + 37] = v_49; + const uint64_t v_51 = seed.word(51); + row[layout.auxiliaries + 38] = v_51; + const uint64_t v_52 = seed.word(52); + row[layout.auxiliaries + 39] = v_52; + const uint64_t v_53 = seed.word(53); + row[layout.auxiliaries + 40] = v_53; + const uint64_t v_54 = seed.word(54); + row[layout.auxiliaries + 41] = v_54; + row[layout.selectors + 0] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_62(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 96 : 440; + const Seed_ixvm_62 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_62(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_62(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_62<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_62<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_62(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 13 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 42) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 440 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_62); +} + +template struct Seed_ixvm_63 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 32); + case 2: return load_u8(data + 33); + case 3: return load_u8(data + 34); + case 4: return load_u8(data + 35); + case 5: return load_u8(data + 36); + case 6: return load_u8(data + 37); + case 7: return load_u8(data + 38); + case 8: return load_u8(data + 39); + case 9: return load_u32(data + 16); + case 10: return load_u64(data + 8); + case 11: return load_u8(data + 40); + case 12: return load_u8(data + 41); + case 13: return load_u8(data + 42); + case 14: return load_u8(data + 43); + case 15: return load_u8(data + 44); + case 16: return load_u8(data + 45); + case 17: return load_u8(data + 46); + case 18: return load_u8(data + 47); + case 19: return load_u8(data + 48); + case 20: return load_u8(data + 49); + case 21: return load_u8(data + 50); + case 22: return load_u8(data + 51); + case 23: return load_u8(data + 52); + case 24: return load_u8(data + 53); + case 25: return load_u8(data + 54); + case 26: return load_u8(data + 55); + case 27: return load_u8(data + 56); + case 28: return load_u32(data + 20); + case 29: return load_u32(data + 24); + case 30: return load_u32(data + 28); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_63(Seed_ixvm_63 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + switch (v_0) { + default: { + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 1] = v_10; + row[layout.auxiliaries + 2] = v_11; + row[layout.auxiliaries + 3] = v_12; + row[layout.auxiliaries + 4] = v_13; + row[layout.auxiliaries + 5] = v_14; + row[layout.auxiliaries + 6] = v_15; + row[layout.auxiliaries + 7] = v_16; + row[layout.auxiliaries + 8] = v_17; + row[layout.auxiliaries + 9] = v_18; + row[layout.auxiliaries + 10] = v_19; + row[layout.auxiliaries + 11] = v_20; + row[layout.auxiliaries + 12] = v_21; + row[layout.auxiliaries + 13] = v_22; + row[layout.auxiliaries + 14] = v_23; + row[layout.auxiliaries + 15] = v_24; + row[layout.auxiliaries + 16] = v_25; + row[layout.auxiliaries + 17] = v_26; + row[layout.auxiliaries + 18] = v_27; + const uint64_t v_28 = seed.word(29); + row[layout.auxiliaries + 19] = v_28; + const uint64_t v_29 = seed.word(30); + row[layout.auxiliaries + 20] = v_29; + row[layout.selectors + 0] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_63(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 248; + const Seed_ixvm_63 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_63(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_63(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_63<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_63<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_63(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 10 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 21) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 248 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_63); +} + +template struct Seed_ixvm_66 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 44); + case 3: return load_u8(data + 45); + case 4: return load_u8(data + 46); + case 5: return load_u8(data + 47); + case 6: return load_u8(data + 48); + case 7: return load_u8(data + 49); + case 8: return load_u8(data + 50); + case 9: return load_u8(data + 51); + case 10: return load_u32(data + 24); + case 11: return load_u64(data + 16); + case 12: return load_u8(data + 52); + case 13: return load_u8(data + 53); + case 14: return load_u8(data + 54); + case 15: return load_u8(data + 55); + case 16: return load_u8(data + 56); + case 17: return load_u8(data + 57); + case 18: return load_u8(data + 58); + case 19: return load_u8(data + 59); + case 20: return load_u8(data + 60); + case 21: return load_u8(data + 61); + case 22: return load_u8(data + 62); + case 23: return load_u8(data + 63); + case 24: return load_u8(data + 64); + case 25: return load_u8(data + 65); + case 26: return load_u8(data + 66); + case 27: return load_u8(data + 67); + case 28: return load_u8(data + 68); + case 29: return load_u32(data + 28); + case 30: return load_u32(data + 32); + case 31: return load_u32(data + 36); + case 32: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_66(Seed_ixvm_66 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + switch (v_0) { + default: { + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + row[layout.auxiliaries + 1] = v_11; + row[layout.auxiliaries + 2] = v_12; + row[layout.auxiliaries + 3] = v_13; + row[layout.auxiliaries + 4] = v_14; + row[layout.auxiliaries + 5] = v_15; + row[layout.auxiliaries + 6] = v_16; + row[layout.auxiliaries + 7] = v_17; + row[layout.auxiliaries + 8] = v_18; + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + row[layout.auxiliaries + 12] = v_22; + row[layout.auxiliaries + 13] = v_23; + row[layout.auxiliaries + 14] = v_24; + row[layout.auxiliaries + 15] = v_25; + row[layout.auxiliaries + 16] = v_26; + row[layout.auxiliaries + 17] = v_27; + row[layout.auxiliaries + 18] = v_28; + const uint64_t v_30 = seed.word(30); + row[layout.auxiliaries + 19] = v_30; + const uint64_t v_31 = seed.word(31); + row[layout.auxiliaries + 20] = v_31; + const uint64_t v_32 = seed.word(32); + row[layout.auxiliaries + 21] = v_32; + row[layout.selectors + 0] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_66(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 72 : 264; + const Seed_ixvm_66 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_66(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_66(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_66<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_66<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_66(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 11 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 72 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_66); +} + +template struct Seed_ixvm_67 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 36); + case 2: return load_u8(data + 37); + case 3: return load_u8(data + 38); + case 4: return load_u8(data + 39); + case 5: return load_u8(data + 40); + case 6: return load_u8(data + 41); + case 7: return load_u8(data + 42); + case 8: return load_u8(data + 43); + case 9: return load_u8(data + 44); + case 10: return load_u32(data + 16); + case 11: return load_u64(data + 8); + case 12: return load_u8(data + 45); + case 13: return load_u8(data + 46); + case 14: return load_u8(data + 47); + case 15: return load_u8(data + 48); + case 16: return load_u8(data + 49); + case 17: return load_u8(data + 50); + case 18: return load_u8(data + 51); + case 19: return load_u8(data + 52); + case 20: return load_u8(data + 53); + case 21: return load_u8(data + 54); + case 22: return load_u8(data + 55); + case 23: return load_u8(data + 56); + case 24: return load_u8(data + 57); + case 25: return load_u8(data + 58); + case 26: return load_u8(data + 59); + case 27: return load_u8(data + 60); + case 28: return load_u8(data + 61); + case 29: return load_u32(data + 20); + case 30: return load_u32(data + 24); + case 31: return load_u32(data + 28); + case 32: return load_u32(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_67(Seed_ixvm_67 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + switch (v_0) { + default: { + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + row[layout.auxiliaries + 1] = v_11; + row[layout.auxiliaries + 2] = v_12; + row[layout.auxiliaries + 3] = v_13; + row[layout.auxiliaries + 4] = v_14; + row[layout.auxiliaries + 5] = v_15; + row[layout.auxiliaries + 6] = v_16; + row[layout.auxiliaries + 7] = v_17; + row[layout.auxiliaries + 8] = v_18; + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + row[layout.auxiliaries + 12] = v_22; + row[layout.auxiliaries + 13] = v_23; + row[layout.auxiliaries + 14] = v_24; + row[layout.auxiliaries + 15] = v_25; + row[layout.auxiliaries + 16] = v_26; + row[layout.auxiliaries + 17] = v_27; + row[layout.auxiliaries + 18] = v_28; + const uint64_t v_29 = seed.word(30); + row[layout.auxiliaries + 19] = v_29; + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 20] = v_30; + const uint64_t v_31 = seed.word(32); + row[layout.auxiliaries + 21] = v_31; + row[layout.selectors + 0] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_67(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 264; + const Seed_ixvm_67 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_67(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_67(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_67<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_67<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_67(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 11 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_67); +} + +template struct Seed_ixvm_68 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 56); + case 3: return load_u8(data + 57); + case 4: return load_u8(data + 58); + case 5: return load_u8(data + 59); + case 6: return load_u8(data + 60); + case 7: return load_u8(data + 61); + case 8: return load_u8(data + 62); + case 9: return load_u8(data + 63); + case 10: return load_u8(data + 64); + case 11: return load_u8(data + 65); + case 12: return load_u8(data + 66); + case 13: return load_u8(data + 67); + case 14: return load_u8(data + 68); + case 15: return load_u8(data + 69); + case 16: return load_u8(data + 70); + case 17: return load_u8(data + 71); + case 18: return load_u8(data + 72); + case 19: return load_u8(data + 73); + case 20: return load_u8(data + 74); + case 21: return load_u8(data + 75); + case 22: return load_u8(data + 76); + case 23: return load_u8(data + 77); + case 24: return load_u8(data + 78); + case 25: return load_u8(data + 79); + case 26: return load_u8(data + 80); + case 27: return load_u8(data + 81); + case 28: return load_u8(data + 82); + case 29: return load_u8(data + 83); + case 30: return load_u8(data + 84); + case 31: return load_u8(data + 85); + case 32: return load_u8(data + 86); + case 33: return load_u8(data + 87); + case 34: return load_u32(data + 24); + case 35: return load_u64(data + 16); + case 36: return load_u8(data + 88); + case 37: return load_u8(data + 89); + case 38: return load_u8(data + 90); + case 39: return load_u8(data + 91); + case 40: return load_u8(data + 92); + case 41: return load_u8(data + 93); + case 42: return load_u8(data + 94); + case 43: return load_u8(data + 95); + case 44: return load_u8(data + 96); + case 45: return load_u8(data + 97); + case 46: return load_u8(data + 98); + case 47: return load_u8(data + 99); + case 48: return load_u8(data + 100); + case 49: return load_u8(data + 101); + case 50: return load_u8(data + 102); + case 51: return load_u8(data + 103); + case 52: return load_u8(data + 104); + case 53: return load_u32(data + 28); + case 54: return load_u32(data + 32); + case 55: return load_u32(data + 36); + case 56: return load_u32(data + 40); + case 57: return load_u32(data + 44); + case 58: return load_u32(data + 48); + case 59: return load_u32(data + 52); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_68(Seed_ixvm_68 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + switch (v_0) { + default: { + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + row[layout.auxiliaries + 1] = v_35; + row[layout.auxiliaries + 2] = v_36; + row[layout.auxiliaries + 3] = v_37; + row[layout.auxiliaries + 4] = v_38; + row[layout.auxiliaries + 5] = v_39; + row[layout.auxiliaries + 6] = v_40; + row[layout.auxiliaries + 7] = v_41; + row[layout.auxiliaries + 8] = v_42; + row[layout.auxiliaries + 9] = v_43; + row[layout.auxiliaries + 10] = v_44; + row[layout.auxiliaries + 11] = v_45; + row[layout.auxiliaries + 12] = v_46; + row[layout.auxiliaries + 13] = v_47; + row[layout.auxiliaries + 14] = v_48; + row[layout.auxiliaries + 15] = v_49; + row[layout.auxiliaries + 16] = v_50; + row[layout.auxiliaries + 17] = v_51; + row[layout.auxiliaries + 18] = v_52; + const uint64_t v_54 = seed.word(54); + row[layout.auxiliaries + 19] = v_54; + const uint64_t v_55 = seed.word(55); + row[layout.auxiliaries + 20] = v_55; + const uint64_t v_56 = seed.word(56); + row[layout.auxiliaries + 21] = v_56; + const uint64_t v_57 = seed.word(57); + row[layout.auxiliaries + 22] = v_57; + const uint64_t v_58 = seed.word(58); + row[layout.auxiliaries + 23] = v_58; + const uint64_t v_59 = seed.word(59); + row[layout.auxiliaries + 24] = v_59; + row[layout.selectors + 0] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_68(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 112 : 480; + const Seed_ixvm_68 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_68(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_68(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_68<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_68<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_68(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 35 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 25) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 480 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_68); +} + +template struct Seed_ixvm_69 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 48); + case 4: return load_u64(data + 16); + case 5: return load_u8(data + 49); + case 6: return load_u8(data + 50); + case 7: return load_u8(data + 51); + case 8: return load_u8(data + 52); + case 9: return load_u8(data + 53); + case 10: return load_u8(data + 54); + case 11: return load_u8(data + 55); + case 12: return load_u8(data + 56); + case 13: return load_u8(data + 57); + case 14: return load_u8(data + 58); + case 15: return load_u8(data + 59); + case 16: return load_u8(data + 60); + case 17: return load_u8(data + 61); + case 18: return load_u8(data + 62); + case 19: return load_u8(data + 63); + case 20: return load_u8(data + 64); + case 21: return load_u8(data + 65); + case 22: return load_u8(data + 66); + case 23: return load_u8(data + 67); + case 24: return load_u8(data + 68); + case 25: return load_u8(data + 69); + case 26: return load_u8(data + 70); + case 27: return load_u8(data + 71); + case 28: return load_u8(data + 72); + case 29: return load_u8(data + 73); + case 30: return load_u8(data + 74); + case 31: return load_u8(data + 75); + case 32: return load_u8(data + 76); + case 33: return load_u8(data + 77); + case 34: return load_u8(data + 78); + case 35: return load_u8(data + 79); + case 36: return load_u8(data + 80); + case 37: return load_u32(data + 36); + case 38: return load_u32(data + 40); + case 39: return load_u64(data + 24); + case 40: return load_u32(data + 44); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_69(Seed_ixvm_69 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.auxiliaries + 27] = v_28; + row[layout.auxiliaries + 28] = v_29; + row[layout.auxiliaries + 29] = v_30; + row[layout.auxiliaries + 30] = v_31; + row[layout.auxiliaries + 31] = v_32; + row[layout.auxiliaries + 32] = v_33; + row[layout.auxiliaries + 33] = v_34; + row[layout.auxiliaries + 34] = v_35; + row[layout.auxiliaries + 35] = v_36; + row[layout.auxiliaries + 36] = v_37; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_38 = seed.word(39); + row[layout.auxiliaries + 37] = v_38; + const uint64_t v_39 = seed.word(40); + row[layout.auxiliaries + 38] = v_39; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_69(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 328; + const Seed_ixvm_69 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_69(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_69(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_69<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_69<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_69(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 39) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 328 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_69); +} + +template struct Seed_ixvm_70 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 68); + case 3: return load_u8(data + 69); + case 4: return load_u8(data + 70); + case 5: return load_u8(data + 71); + case 6: return load_u8(data + 72); + case 7: return load_u8(data + 73); + case 8: return load_u8(data + 74); + case 9: return load_u8(data + 75); + case 10: return load_u8(data + 76); + case 11: return load_u8(data + 77); + case 12: return load_u8(data + 78); + case 13: return load_u8(data + 79); + case 14: return load_u8(data + 80); + case 15: return load_u8(data + 81); + case 16: return load_u8(data + 82); + case 17: return load_u8(data + 83); + case 18: return load_u8(data + 84); + case 19: return load_u8(data + 85); + case 20: return load_u8(data + 86); + case 21: return load_u8(data + 87); + case 22: return load_u8(data + 88); + case 23: return load_u8(data + 89); + case 24: return load_u8(data + 90); + case 25: return load_u8(data + 91); + case 26: return load_u32(data + 32); + case 27: return load_u32(data + 36); + case 28: return load_u64(data + 16); + case 29: return load_u8(data + 92); + case 30: return load_u8(data + 93); + case 31: return load_u8(data + 94); + case 32: return load_u8(data + 95); + case 33: return load_u8(data + 96); + case 34: return load_u8(data + 97); + case 35: return load_u8(data + 98); + case 36: return load_u8(data + 99); + case 37: return load_u8(data + 100); + case 38: return load_u8(data + 101); + case 39: return load_u8(data + 102); + case 40: return load_u8(data + 103); + case 41: return load_u8(data + 104); + case 42: return load_u8(data + 105); + case 43: return load_u8(data + 106); + case 44: return load_u8(data + 107); + case 45: return load_u8(data + 108); + case 46: return load_u32(data + 40); + case 47: return load_u8(data + 109); + case 48: return load_u8(data + 110); + case 49: return load_u8(data + 111); + case 50: return load_u8(data + 112); + case 51: return load_u8(data + 113); + case 52: return load_u8(data + 114); + case 53: return load_u8(data + 115); + case 54: return load_u8(data + 116); + case 55: return load_u64(data + 24); + case 56: return load_u32(data + 44); + case 57: return load_u32(data + 48); + case 58: return load_u32(data + 52); + case 59: return load_u32(data + 56); + case 60: return load_u32(data + 60); + case 61: return load_u32(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_70(Seed_ixvm_70 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + switch (v_0) { + default: { + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + row[layout.auxiliaries + 1] = v_28; + row[layout.auxiliaries + 2] = v_29; + row[layout.auxiliaries + 3] = v_30; + row[layout.auxiliaries + 4] = v_31; + row[layout.auxiliaries + 5] = v_32; + row[layout.auxiliaries + 6] = v_33; + row[layout.auxiliaries + 7] = v_34; + row[layout.auxiliaries + 8] = v_35; + row[layout.auxiliaries + 9] = v_36; + row[layout.auxiliaries + 10] = v_37; + row[layout.auxiliaries + 11] = v_38; + row[layout.auxiliaries + 12] = v_39; + row[layout.auxiliaries + 13] = v_40; + row[layout.auxiliaries + 14] = v_41; + row[layout.auxiliaries + 15] = v_42; + row[layout.auxiliaries + 16] = v_43; + row[layout.auxiliaries + 17] = v_44; + row[layout.auxiliaries + 18] = v_45; + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + row[layout.auxiliaries + 19] = v_46; + row[layout.auxiliaries + 20] = v_47; + row[layout.auxiliaries + 21] = v_48; + row[layout.auxiliaries + 22] = v_49; + row[layout.auxiliaries + 23] = v_50; + row[layout.auxiliaries + 24] = v_51; + row[layout.auxiliaries + 25] = v_52; + row[layout.auxiliaries + 26] = v_53; + const uint64_t v_55 = seed.word(55); + row[layout.auxiliaries + 27] = v_55; + const uint64_t v_56 = seed.word(56); + row[layout.auxiliaries + 28] = v_56; + const uint64_t v_57 = seed.word(57); + row[layout.auxiliaries + 29] = v_57; + const uint64_t v_58 = seed.word(58); + row[layout.auxiliaries + 30] = v_58; + const uint64_t v_59 = seed.word(59); + row[layout.auxiliaries + 31] = v_59; + const uint64_t v_60 = seed.word(60); + row[layout.auxiliaries + 32] = v_60; + const uint64_t v_61 = seed.word(61); + row[layout.auxiliaries + 33] = v_61; + row[layout.selectors + 0] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_70(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 120 : 496; + const Seed_ixvm_70 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_70(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_70(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_70<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_70<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_70(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 28 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 34) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 496 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_70); +} + +template struct Seed_ixvm_73 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 32); + case 2: return load_u8(data + 33); + case 3: return load_u8(data + 34); + case 4: return load_u8(data + 35); + case 5: return load_u8(data + 36); + case 6: return load_u8(data + 37); + case 7: return load_u8(data + 38); + case 8: return load_u8(data + 39); + case 9: return load_u8(data + 40); + case 10: return load_u8(data + 41); + case 11: return load_u8(data + 42); + case 12: return load_u8(data + 43); + case 13: return load_u8(data + 44); + case 14: return load_u8(data + 45); + case 15: return load_u8(data + 46); + case 16: return load_u8(data + 47); + case 17: return load_u8(data + 48); + case 18: return load_u8(data + 49); + case 19: return load_u8(data + 50); + case 20: return load_u8(data + 51); + case 21: return load_u8(data + 52); + case 22: return load_u8(data + 53); + case 23: return load_u8(data + 54); + case 24: return load_u8(data + 55); + case 25: return load_u8(data + 56); + case 26: return load_u8(data + 57); + case 27: return load_u8(data + 58); + case 28: return load_u8(data + 59); + case 29: return load_u8(data + 60); + case 30: return load_u8(data + 61); + case 31: return load_u8(data + 62); + case 32: return load_u8(data + 63); + case 33: return load_u8(data + 64); + case 34: return load_u8(data + 65); + case 35: return load_u8(data + 66); + case 36: return load_u8(data + 67); + case 37: return load_u8(data + 68); + case 38: return load_u8(data + 69); + case 39: return load_u8(data + 70); + case 40: return load_u8(data + 71); + case 41: return load_u8(data + 72); + case 42: return load_u8(data + 73); + case 43: return load_u8(data + 74); + case 44: return load_u32(data + 16); + case 45: return load_u32(data + 20); + case 46: return load_u64(data + 8); + case 47: return load_u32(data + 24); + case 48: return load_u32(data + 28); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_73(Seed_ixvm_73 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + switch (v_0) { + case 0ULL: { + const uint64_t v_47 = seed.word(47); + row[layout.auxiliaries + 1] = v_47; + const uint64_t v_48 = seed.word(48); + row[layout.auxiliaries + 2] = v_48; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_51 = seed.word(47); + row[layout.auxiliaries + 1] = v_51; + const uint64_t v_52 = seed.word(48); + row[layout.auxiliaries + 2] = v_52; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_55 = seed.word(47); + row[layout.auxiliaries + 1] = v_55; + const uint64_t v_56 = seed.word(48); + row[layout.auxiliaries + 2] = v_56; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_73(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 80 : 392; + const Seed_ixvm_73 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_73(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_73(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_73<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_73<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_73(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 46 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 392 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_73); +} + +template struct Seed_ixvm_74 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 44); + case 4: return load_u8(data + 45); + case 5: return load_u8(data + 46); + case 6: return load_u8(data + 47); + case 7: return load_u8(data + 48); + case 8: return load_u8(data + 49); + case 9: return load_u8(data + 50); + case 10: return load_u8(data + 51); + case 11: return load_u8(data + 52); + case 12: return load_u8(data + 53); + case 13: return load_u8(data + 54); + case 14: return load_u8(data + 55); + case 15: return load_u8(data + 56); + case 16: return load_u8(data + 57); + case 17: return load_u8(data + 58); + case 18: return load_u8(data + 59); + case 19: return load_u8(data + 60); + case 20: return load_u8(data + 61); + case 21: return load_u8(data + 62); + case 22: return load_u8(data + 63); + case 23: return load_u8(data + 64); + case 24: return load_u8(data + 65); + case 25: return load_u8(data + 66); + case 26: return load_u8(data + 67); + case 27: return load_u8(data + 68); + case 28: return load_u8(data + 69); + case 29: return load_u8(data + 70); + case 30: return load_u8(data + 71); + case 31: return load_u8(data + 72); + case 32: return load_u8(data + 73); + case 33: return load_u8(data + 74); + case 34: return load_u8(data + 75); + case 35: return load_u8(data + 76); + case 36: return load_u8(data + 77); + case 37: return load_u8(data + 78); + case 38: return load_u8(data + 79); + case 39: return load_u8(data + 80); + case 40: return load_u8(data + 81); + case 41: return load_u8(data + 82); + case 42: return load_u8(data + 83); + case 43: return load_u8(data + 84); + case 44: return load_u8(data + 85); + case 45: return load_u8(data + 86); + case 46: return load_u8(data + 87); + case 47: return load_u32(data + 28); + case 48: return load_u32(data + 32); + case 49: return load_u32(data + 36); + case 50: return load_u64(data + 16); + case 51: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_74(Seed_ixvm_74 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.auxiliaries + 27] = v_28; + row[layout.auxiliaries + 28] = v_29; + row[layout.auxiliaries + 29] = v_30; + row[layout.auxiliaries + 30] = v_31; + row[layout.auxiliaries + 31] = v_32; + row[layout.auxiliaries + 32] = v_33; + row[layout.auxiliaries + 33] = v_34; + row[layout.auxiliaries + 34] = v_35; + row[layout.auxiliaries + 35] = v_36; + row[layout.auxiliaries + 36] = v_37; + row[layout.auxiliaries + 37] = v_38; + row[layout.auxiliaries + 38] = v_39; + row[layout.auxiliaries + 39] = v_40; + row[layout.auxiliaries + 40] = v_41; + row[layout.auxiliaries + 41] = v_42; + row[layout.auxiliaries + 42] = v_43; + row[layout.auxiliaries + 43] = v_44; + row[layout.auxiliaries + 44] = v_45; + row[layout.auxiliaries + 45] = v_46; + row[layout.auxiliaries + 46] = v_47; + row[layout.auxiliaries + 47] = v_48; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_49 = seed.word(50); + row[layout.auxiliaries + 48] = v_49; + const uint64_t v_50 = seed.word(51); + row[layout.auxiliaries + 49] = v_50; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_74(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 416; + const Seed_ixvm_74 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_74(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_74(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_74<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_74<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_74(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 50) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 416 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_74); +} + +template struct Seed_ixvm_80 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u8(data + 28); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_80(Seed_ixvm_80 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_80(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 40; + const Seed_ixvm_80 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_80(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_80(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_80<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_80<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_80(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_80); +} + +__device__ __constant__ uint64_t inverse_81_0[] = {0ULL}; +template struct Seed_ixvm_81 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 104); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 100); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u64(data + 40); + case 9: return load_u64(data + 48); + case 10: return load_u64(data + 56); + case 11: return load_u64(data + 64); + case 12: return load_u64(data + 72); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_81(Seed_ixvm_81 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_81_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_3 = seed.word(3); + const uint64_t v_4 = seed.word(4); + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_3) { + case 0ULL: { + const uint64_t v_8 = seed.word(6); + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 5] = v_8; + row[layout.auxiliaries + 6] = v_9; + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_81(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 112 : 120; + const Seed_ixvm_81 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_81(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_81(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_81<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_81<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_81(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 120 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_81); +} + +template struct Seed_ixvm_82 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u8(data + 32); + case 3: return load_u8(data + 33); + case 4: return load_u32(data + 28); + case 5: return load_u8(data + 34); + case 6: return load_u64(data + 8); + case 7: return load_u8(data + 35); + case 8: return load_u8(data + 36); + case 9: return load_u8(data + 37); + case 10: return load_u8(data + 38); + case 11: return load_u8(data + 39); + case 12: return load_u8(data + 40); + case 13: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_82(Seed_ixvm_82 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = ((v_2 >> 0) & 1ULL); + const uint64_t v_5 = ((v_2 >> 1) & 1ULL); + const uint64_t v_6 = ((v_2 >> 2) & 1ULL); + const uint64_t v_7 = ((v_2 >> 3) & 1ULL); + const uint64_t v_8 = ((v_2 >> 4) & 1ULL); + const uint64_t v_9 = ((v_2 >> 5) & 1ULL); + const uint64_t v_10 = ((v_2 >> 6) & 1ULL); + const uint64_t v_11 = ((v_2 >> 7) & 1ULL); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + switch (v_7) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_27 = seed.word(5); + const uint64_t v_28 = seed.word(6); + const uint64_t v_29 = seed.word(7); + const uint64_t v_30 = seed.word(8); + const uint64_t v_31 = seed.word(9); + const uint64_t v_32 = seed.word(10); + const uint64_t v_33 = seed.word(11); + const uint64_t v_34 = seed.word(12); + const uint64_t v_35 = seed.word(13); + row[layout.auxiliaries + 12] = v_27; + row[layout.auxiliaries + 13] = v_28; + row[layout.auxiliaries + 14] = v_29; + row[layout.auxiliaries + 15] = v_30; + row[layout.auxiliaries + 16] = v_31; + row[layout.auxiliaries + 17] = v_32; + row[layout.auxiliaries + 18] = v_33; + row[layout.auxiliaries + 19] = v_34; + row[layout.auxiliaries + 20] = v_35; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_82(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 112; + const Seed_ixvm_82 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_82(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_82(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_82<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_82<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_82(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 21) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 112 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_82); +} + +template struct Seed_ixvm_84 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u8(data + 32); + case 3: return load_u8(data + 33); + case 4: return load_u32(data + 28); + case 5: return load_u8(data + 34); + case 6: return load_u64(data + 8); + case 7: return load_u8(data + 35); + case 8: return load_u8(data + 36); + case 9: return load_u8(data + 37); + case 10: return load_u8(data + 38); + case 11: return load_u8(data + 39); + case 12: return load_u8(data + 40); + case 13: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_84(Seed_ixvm_84 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = 128ULL; + if (v_2 > 255 || v_4 > 255) return 1; + const uint64_t v_5 = uint64_t(v_2 < v_4); + row[layout.auxiliaries + 4] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_10 = seed.word(5); + const uint64_t v_11 = seed.word(6); + const uint64_t v_12 = seed.word(7); + const uint64_t v_13 = seed.word(8); + const uint64_t v_14 = seed.word(9); + const uint64_t v_15 = seed.word(10); + const uint64_t v_16 = seed.word(11); + const uint64_t v_17 = seed.word(12); + const uint64_t v_18 = seed.word(13); + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.auxiliaries + 7] = v_12; + row[layout.auxiliaries + 8] = v_13; + row[layout.auxiliaries + 9] = v_14; + row[layout.auxiliaries + 10] = v_15; + row[layout.auxiliaries + 11] = v_16; + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_84(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 112; + const Seed_ixvm_84 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_84(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_84(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_84<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_84<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_84(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 112 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_84); +} + +template struct Seed_ixvm_85 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 28); + case 2: return load_u8(data + 29); + case 3: return load_u32(data + 24); + case 4: return load_u8(data + 30); + case 5: return load_u8(data + 31); + case 6: return load_u64(data + 8); + case 7: return load_u8(data + 32); + case 8: return load_u8(data + 33); + case 9: return load_u8(data + 34); + case 10: return load_u8(data + 35); + case 11: return load_u8(data + 36); + case 12: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_85(Seed_ixvm_85 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + if (v_0 > 255 || v_1 > 255) return 1; + const uint64_t v_3 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 1] = v_3; + switch (v_3) { + case 1ULL: { + const uint64_t v_4 = seed.word(4); + const uint64_t v_5 = seed.word(5); + const uint64_t v_6 = seed.word(6); + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_4) { + case 0ULL: { + const uint64_t v_7 = 2ULL; + const uint64_t v_8 = goldilocks_mul(v_7, v_1); + if (v_5 > 255 || v_8 > 255) return 1; + const uint64_t v_9 = ((v_5 + v_8) & 255ULL); + const uint64_t v_10 = ((v_5 + v_8) >> 8); + row[layout.auxiliaries + 5] = v_9; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 0ULL: { + const uint64_t v_14 = seed.word(4); + const uint64_t v_15 = seed.word(5); + const uint64_t v_16 = seed.word(6); + const uint64_t v_17 = seed.word(7); + const uint64_t v_18 = seed.word(8); + const uint64_t v_19 = seed.word(9); + const uint64_t v_20 = seed.word(10); + const uint64_t v_21 = seed.word(11); + const uint64_t v_22 = seed.word(12); + row[layout.auxiliaries + 2] = v_14; + row[layout.auxiliaries + 3] = v_15; + row[layout.auxiliaries + 4] = v_16; + row[layout.auxiliaries + 5] = v_17; + row[layout.auxiliaries + 6] = v_18; + row[layout.auxiliaries + 7] = v_19; + row[layout.auxiliaries + 8] = v_20; + row[layout.auxiliaries + 9] = v_21; + row[layout.auxiliaries + 10] = v_22; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_85(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 104; + const Seed_ixvm_85 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_85(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_85(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_85<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_85<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_85(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 11) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_85); +} + +template struct Seed_ixvm_86 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 20); + case 2: return load_u8(data + 21); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 22); + case 5: return load_u8(data + 23); + case 6: return load_u8(data + 24); + case 7: return load_u8(data + 25); + case 8: return load_u8(data + 26); + case 9: return load_u8(data + 27); + case 10: return load_u8(data + 28); + case 11: return load_u8(data + 29); + case 12: return load_u64(data + 8); + case 13: return load_u8(data + 30); + case 14: return load_u8(data + 31); + case 15: return load_u8(data + 32); + case 16: return load_u8(data + 33); + case 17: return load_u8(data + 34); + case 18: return load_u8(data + 35); + case 19: return load_u8(data + 36); + case 20: return load_u8(data + 37); + case 21: return load_u8(data + 38); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_86(Seed_ixvm_86 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + switch (v_0) { + case 0ULL: { + const uint64_t v_6 = seed.word(4); + const uint64_t v_7 = seed.word(5); + const uint64_t v_8 = seed.word(6); + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + row[layout.auxiliaries + 1] = v_6; + row[layout.auxiliaries + 2] = v_7; + row[layout.auxiliaries + 3] = v_8; + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.auxiliaries + 7] = v_12; + row[layout.auxiliaries + 8] = v_13; + row[layout.auxiliaries + 9] = v_14; + const uint64_t v_16 = seed.word(13); + const uint64_t v_17 = seed.word(14); + const uint64_t v_18 = seed.word(15); + const uint64_t v_19 = seed.word(16); + const uint64_t v_20 = seed.word(17); + const uint64_t v_21 = seed.word(18); + const uint64_t v_22 = seed.word(19); + const uint64_t v_23 = seed.word(20); + const uint64_t v_24 = seed.word(21); + row[layout.auxiliaries + 10] = v_16; + row[layout.auxiliaries + 11] = v_17; + row[layout.auxiliaries + 12] = v_18; + row[layout.auxiliaries + 13] = v_19; + row[layout.auxiliaries + 14] = v_20; + row[layout.auxiliaries + 15] = v_21; + row[layout.auxiliaries + 16] = v_22; + row[layout.auxiliaries + 17] = v_23; + row[layout.auxiliaries + 18] = v_24; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_26 = seed.word(4); + const uint64_t v_27 = seed.word(5); + const uint64_t v_28 = seed.word(6); + const uint64_t v_29 = seed.word(7); + const uint64_t v_30 = seed.word(8); + const uint64_t v_31 = seed.word(9); + const uint64_t v_32 = seed.word(10); + const uint64_t v_33 = seed.word(11); + const uint64_t v_34 = seed.word(12); + row[layout.auxiliaries + 1] = v_26; + row[layout.auxiliaries + 2] = v_27; + row[layout.auxiliaries + 3] = v_28; + row[layout.auxiliaries + 4] = v_29; + row[layout.auxiliaries + 5] = v_30; + row[layout.auxiliaries + 6] = v_31; + row[layout.auxiliaries + 7] = v_32; + row[layout.auxiliaries + 8] = v_33; + row[layout.auxiliaries + 9] = v_34; + const uint64_t v_37 = seed.word(13); + const uint64_t v_38 = seed.word(14); + const uint64_t v_39 = seed.word(15); + const uint64_t v_40 = seed.word(16); + const uint64_t v_41 = seed.word(17); + const uint64_t v_42 = seed.word(18); + const uint64_t v_43 = seed.word(19); + const uint64_t v_44 = seed.word(20); + const uint64_t v_45 = seed.word(21); + row[layout.auxiliaries + 10] = v_37; + row[layout.auxiliaries + 11] = v_38; + row[layout.auxiliaries + 12] = v_39; + row[layout.auxiliaries + 13] = v_40; + row[layout.auxiliaries + 14] = v_41; + row[layout.auxiliaries + 15] = v_42; + row[layout.auxiliaries + 16] = v_43; + row[layout.auxiliaries + 17] = v_44; + row[layout.auxiliaries + 18] = v_45; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_47 = seed.word(4); + const uint64_t v_48 = seed.word(5); + const uint64_t v_49 = seed.word(6); + const uint64_t v_50 = seed.word(7); + const uint64_t v_51 = seed.word(8); + const uint64_t v_52 = seed.word(9); + const uint64_t v_53 = seed.word(10); + const uint64_t v_54 = seed.word(11); + const uint64_t v_55 = seed.word(12); + row[layout.auxiliaries + 1] = v_47; + row[layout.auxiliaries + 2] = v_48; + row[layout.auxiliaries + 3] = v_49; + row[layout.auxiliaries + 4] = v_50; + row[layout.auxiliaries + 5] = v_51; + row[layout.auxiliaries + 6] = v_52; + row[layout.auxiliaries + 7] = v_53; + row[layout.auxiliaries + 8] = v_54; + row[layout.auxiliaries + 9] = v_55; + const uint64_t v_58 = seed.word(13); + const uint64_t v_59 = seed.word(14); + const uint64_t v_60 = seed.word(15); + const uint64_t v_61 = seed.word(16); + const uint64_t v_62 = seed.word(17); + const uint64_t v_63 = seed.word(18); + const uint64_t v_64 = seed.word(19); + const uint64_t v_65 = seed.word(20); + const uint64_t v_66 = seed.word(21); + row[layout.auxiliaries + 10] = v_58; + row[layout.auxiliaries + 11] = v_59; + row[layout.auxiliaries + 12] = v_60; + row[layout.auxiliaries + 13] = v_61; + row[layout.auxiliaries + 14] = v_62; + row[layout.auxiliaries + 15] = v_63; + row[layout.auxiliaries + 16] = v_64; + row[layout.auxiliaries + 17] = v_65; + row[layout.auxiliaries + 18] = v_66; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_68 = seed.word(4); + const uint64_t v_69 = seed.word(5); + const uint64_t v_70 = seed.word(6); + const uint64_t v_71 = seed.word(7); + const uint64_t v_72 = seed.word(8); + const uint64_t v_73 = seed.word(9); + const uint64_t v_74 = seed.word(10); + const uint64_t v_75 = seed.word(11); + const uint64_t v_76 = seed.word(12); + row[layout.auxiliaries + 1] = v_68; + row[layout.auxiliaries + 2] = v_69; + row[layout.auxiliaries + 3] = v_70; + row[layout.auxiliaries + 4] = v_71; + row[layout.auxiliaries + 5] = v_72; + row[layout.auxiliaries + 6] = v_73; + row[layout.auxiliaries + 7] = v_74; + row[layout.auxiliaries + 8] = v_75; + row[layout.auxiliaries + 9] = v_76; + const uint64_t v_79 = seed.word(13); + const uint64_t v_80 = seed.word(14); + const uint64_t v_81 = seed.word(15); + const uint64_t v_82 = seed.word(16); + const uint64_t v_83 = seed.word(17); + const uint64_t v_84 = seed.word(18); + const uint64_t v_85 = seed.word(19); + const uint64_t v_86 = seed.word(20); + const uint64_t v_87 = seed.word(21); + row[layout.auxiliaries + 10] = v_79; + row[layout.auxiliaries + 11] = v_80; + row[layout.auxiliaries + 12] = v_81; + row[layout.auxiliaries + 13] = v_82; + row[layout.auxiliaries + 14] = v_83; + row[layout.auxiliaries + 15] = v_84; + row[layout.auxiliaries + 16] = v_85; + row[layout.auxiliaries + 17] = v_86; + row[layout.auxiliaries + 18] = v_87; + row[layout.selectors + 3] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_86(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 176; + const Seed_ixvm_86 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_86(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_86(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_86<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_86<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_86(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 19) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 176 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_86); +} + +template struct Seed_ixvm_88 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 168); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u8(data + 180); + case 12: return load_u64(data + 80); + case 13: return load_u32(data + 172); + case 14: return load_u32(data + 176); + case 15: return load_u64(data + 88); + case 16: return load_u64(data + 96); + case 17: return load_u64(data + 104); + case 18: return load_u64(data + 112); + case 19: return load_u64(data + 120); + case 20: return load_u64(data + 128); + case 21: return load_u64(data + 136); + case 22: return load_u64(data + 144); + case 23: return load_u64(data + 152); + case 24: return load_u64(data + 160); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_88(Seed_ixvm_88 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_10; + switch (v_10) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 2] = v_11; + row[layout.auxiliaries + 3] = v_12; + const uint64_t v_15 = seed.word(14); + row[layout.auxiliaries + 4] = v_15; + const uint64_t v_16 = seed.word(15); + const uint64_t v_17 = seed.word(16); + const uint64_t v_18 = seed.word(17); + const uint64_t v_19 = seed.word(18); + const uint64_t v_20 = seed.word(19); + const uint64_t v_21 = seed.word(20); + const uint64_t v_22 = seed.word(21); + const uint64_t v_23 = seed.word(22); + row[layout.auxiliaries + 5] = v_16; + row[layout.auxiliaries + 6] = v_17; + row[layout.auxiliaries + 7] = v_18; + row[layout.auxiliaries + 8] = v_19; + row[layout.auxiliaries + 9] = v_20; + row[layout.auxiliaries + 10] = v_21; + row[layout.auxiliaries + 11] = v_22; + row[layout.auxiliaries + 12] = v_23; + const uint64_t v_24 = seed.word(23); + const uint64_t v_25 = seed.word(24); + row[layout.auxiliaries + 13] = v_24; + row[layout.auxiliaries + 14] = v_25; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_88(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 184 : 200; + const Seed_ixvm_88 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_88(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_88(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_88<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_88<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_88(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 10 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_88); +} + +template struct Seed_ixvm_91 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u8(data + 20); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 21); + case 5: return load_u8(data + 22); + case 6: return load_u8(data + 23); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_91(Seed_ixvm_91 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + const uint64_t v_3 = ((v_1 >> 0) & 1ULL); + const uint64_t v_4 = ((v_1 >> 1) & 1ULL); + const uint64_t v_5 = ((v_1 >> 2) & 1ULL); + const uint64_t v_6 = ((v_1 >> 3) & 1ULL); + const uint64_t v_7 = ((v_1 >> 4) & 1ULL); + const uint64_t v_8 = ((v_1 >> 5) & 1ULL); + const uint64_t v_9 = ((v_1 >> 6) & 1ULL); + const uint64_t v_10 = ((v_1 >> 7) & 1ULL); + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_15 = seed.word(4); + const uint64_t v_16 = seed.word(5); + const uint64_t v_17 = seed.word(6); + row[layout.auxiliaries + 11] = v_15; + row[layout.auxiliaries + 12] = v_16; + row[layout.auxiliaries + 13] = v_17; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_91(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 56; + const Seed_ixvm_91 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_91(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_91(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_91<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_91<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_91(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_91); +} + +template struct Seed_ixvm_92 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u8(data + 20); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 21); + case 5: return load_u8(data + 22); + case 6: return load_u8(data + 23); + case 7: return load_u8(data + 24); + case 8: return load_u8(data + 25); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_92(Seed_ixvm_92 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + const uint64_t v_3 = ((v_1 >> 0) & 1ULL); + const uint64_t v_4 = ((v_1 >> 1) & 1ULL); + const uint64_t v_5 = ((v_1 >> 2) & 1ULL); + const uint64_t v_6 = ((v_1 >> 3) & 1ULL); + const uint64_t v_7 = ((v_1 >> 4) & 1ULL); + const uint64_t v_8 = ((v_1 >> 5) & 1ULL); + const uint64_t v_9 = ((v_1 >> 6) & 1ULL); + const uint64_t v_10 = ((v_1 >> 7) & 1ULL); + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_13 = seed.word(4); + const uint64_t v_14 = seed.word(5); + const uint64_t v_15 = seed.word(6); + row[layout.auxiliaries + 11] = v_13; + row[layout.auxiliaries + 12] = v_14; + row[layout.auxiliaries + 13] = v_15; + const uint64_t v_16 = seed.word(7); + const uint64_t v_17 = seed.word(8); + row[layout.auxiliaries + 14] = v_16; + row[layout.auxiliaries + 15] = v_17; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_92(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 72; + const Seed_ixvm_92 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_92(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_92(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_92<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_92<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_92(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 72 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_92); +} + +__device__ __constant__ uint64_t inverse_95_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_95 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 128); + case 2: return load_u8(data + 140); + case 3: return load_u8(data + 141); + case 4: return load_u64(data + 8); + case 5: return load_u8(data + 142); + case 6: return load_u8(data + 143); + case 7: return load_u8(data + 144); + case 8: return load_u8(data + 145); + case 9: return load_u8(data + 146); + case 10: return load_u8(data + 147); + case 11: return load_u32(data + 132); + case 12: return load_u64(data + 16); + case 13: return load_u64(data + 24); + case 14: return load_u64(data + 32); + case 15: return load_u8(data + 148); + case 16: return load_u64(data + 40); + case 17: return load_u64(data + 48); + case 18: return load_u8(data + 149); + case 19: return load_u64(data + 56); + case 20: return load_u64(data + 64); + case 21: return load_u64(data + 72); + case 22: return load_u64(data + 80); + case 23: return load_u64(data + 88); + case 24: return load_u32(data + 136); + case 25: return load_u64(data + 96); + case 26: return load_u8(data + 150); + case 27: return load_u8(data + 151); + case 28: return load_u8(data + 152); + case 29: return load_u8(data + 153); + case 30: return load_u8(data + 154); + case 31: return load_u8(data + 155); + case 32: return load_u64(data + 104); + case 33: return load_u64(data + 112); + case 34: return load_u64(data + 120); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_95(Seed_ixvm_95 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + switch (v_1) { + case 0ULL: { + const uint64_t v_12 = seed.word(12); + row[layout.auxiliaries + 11] = v_12; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_15 = seed.word(12); + row[layout.auxiliaries + 11] = v_15; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_16 = seed.word(12); + const uint64_t v_17 = seed.word(13); + const uint64_t v_18 = seed.word(14); + const uint64_t v_19 = seed.word(15); + const uint64_t v_20 = seed.word(16); + const uint64_t v_21 = seed.word(17); + const uint64_t v_22 = seed.word(18); + const uint64_t v_23 = seed.word(19); + const uint64_t v_24 = seed.word(20); + row[layout.auxiliaries + 11] = v_16; + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.auxiliaries + 14] = v_19; + row[layout.auxiliaries + 15] = v_20; + row[layout.auxiliaries + 16] = v_21; + row[layout.auxiliaries + 17] = v_22; + row[layout.auxiliaries + 18] = v_23; + row[layout.auxiliaries + 19] = v_24; + const uint64_t v_25 = seed.word(21); + const uint64_t v_26 = seed.word(22); + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + const uint64_t v_29 = seed.word(23); + row[layout.auxiliaries + 22] = v_29; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_30 = seed.word(12); + const uint64_t v_31 = seed.word(13); + const uint64_t v_32 = seed.word(14); + const uint64_t v_33 = seed.word(15); + const uint64_t v_34 = seed.word(16); + const uint64_t v_35 = seed.word(17); + const uint64_t v_36 = seed.word(18); + const uint64_t v_37 = seed.word(19); + const uint64_t v_38 = seed.word(20); + row[layout.auxiliaries + 11] = v_30; + row[layout.auxiliaries + 12] = v_31; + row[layout.auxiliaries + 13] = v_32; + row[layout.auxiliaries + 14] = v_33; + row[layout.auxiliaries + 15] = v_34; + row[layout.auxiliaries + 16] = v_35; + row[layout.auxiliaries + 17] = v_36; + row[layout.auxiliaries + 18] = v_37; + row[layout.auxiliaries + 19] = v_38; + const uint64_t v_39 = seed.word(21); + const uint64_t v_40 = seed.word(22); + row[layout.auxiliaries + 20] = v_39; + row[layout.auxiliaries + 21] = v_40; + const uint64_t v_43 = seed.word(23); + row[layout.auxiliaries + 22] = v_43; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_44 = seed.word(12); + const uint64_t v_45 = seed.word(13); + const uint64_t v_46 = seed.word(14); + const uint64_t v_47 = seed.word(15); + const uint64_t v_48 = seed.word(16); + const uint64_t v_49 = seed.word(17); + const uint64_t v_50 = seed.word(18); + const uint64_t v_51 = seed.word(19); + const uint64_t v_52 = seed.word(20); + row[layout.auxiliaries + 11] = v_44; + row[layout.auxiliaries + 12] = v_45; + row[layout.auxiliaries + 13] = v_46; + row[layout.auxiliaries + 14] = v_47; + row[layout.auxiliaries + 15] = v_48; + row[layout.auxiliaries + 16] = v_49; + row[layout.auxiliaries + 17] = v_50; + row[layout.auxiliaries + 18] = v_51; + row[layout.auxiliaries + 19] = v_52; + const uint64_t v_53 = seed.word(21); + const uint64_t v_54 = seed.word(22); + row[layout.auxiliaries + 20] = v_53; + row[layout.auxiliaries + 21] = v_54; + const uint64_t v_56 = seed.word(23); + row[layout.auxiliaries + 22] = v_56; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_59 = seed.word(12); + row[layout.auxiliaries + 11] = v_59; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_62 = seed.word(12); + row[layout.auxiliaries + 11] = v_62; + row[layout.selectors + 6] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_63 = seed.word(12); + row[layout.auxiliaries + 11] = v_63; + const uint64_t v_65 = seed.word(13); + const uint64_t v_66 = seed.word(14); + row[layout.auxiliaries + 12] = v_65; + row[layout.auxiliaries + 13] = v_66; + const uint64_t v_67 = seed.word(15); + const uint64_t v_68 = seed.word(16); + const uint64_t v_69 = seed.word(17); + const uint64_t v_70 = seed.word(18); + const uint64_t v_71 = seed.word(19); + const uint64_t v_72 = seed.word(20); + const uint64_t v_73 = seed.word(21); + const uint64_t v_74 = seed.word(22); + const uint64_t v_75 = seed.word(23); + const uint64_t v_76 = seed.word(24); + const uint64_t v_77 = seed.word(25); + const uint64_t v_78 = seed.word(26); + const uint64_t v_79 = seed.word(27); + const uint64_t v_80 = seed.word(28); + const uint64_t v_81 = seed.word(29); + const uint64_t v_82 = seed.word(30); + const uint64_t v_83 = seed.word(31); + const uint64_t v_84 = seed.word(32); + row[layout.auxiliaries + 14] = v_67; + row[layout.auxiliaries + 15] = v_68; + row[layout.auxiliaries + 16] = v_69; + row[layout.auxiliaries + 17] = v_70; + row[layout.auxiliaries + 18] = v_71; + row[layout.auxiliaries + 19] = v_72; + row[layout.auxiliaries + 20] = v_73; + row[layout.auxiliaries + 21] = v_74; + row[layout.auxiliaries + 22] = v_75; + row[layout.auxiliaries + 23] = v_76; + row[layout.auxiliaries + 24] = v_77; + row[layout.auxiliaries + 25] = v_78; + row[layout.auxiliaries + 26] = v_79; + row[layout.auxiliaries + 27] = v_80; + row[layout.auxiliaries + 28] = v_81; + row[layout.auxiliaries + 29] = v_82; + row[layout.auxiliaries + 30] = v_83; + row[layout.auxiliaries + 31] = v_84; + switch (v_67) { + case 7ULL: { + const uint64_t v_87 = seed.word(33); + const uint64_t v_88 = seed.word(34); + row[layout.auxiliaries + 32] = v_87; + row[layout.auxiliaries + 33] = v_88; + row[layout.selectors + 7] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 32] = (v_67 <= 7ULL ? inverse_95_0[v_67] : inverse(goldilocks_sub(v_67, 7ULL))); + const uint64_t v_89 = seed.word(33); + const uint64_t v_90 = seed.word(34); + row[layout.auxiliaries + 33] = v_89; + row[layout.auxiliaries + 34] = v_90; + row[layout.selectors + 8] = 1; + return 0; + } + } + } + case 8ULL: { + const uint64_t v_91 = seed.word(12); + row[layout.auxiliaries + 11] = v_91; + const uint64_t v_93 = seed.word(13); + const uint64_t v_94 = seed.word(14); + row[layout.auxiliaries + 12] = v_93; + row[layout.auxiliaries + 13] = v_94; + row[layout.selectors + 9] = 1; + return 0; + } + case 9ULL: { + const uint64_t v_95 = seed.word(12); + row[layout.auxiliaries + 11] = v_95; + const uint64_t v_97 = seed.word(13); + const uint64_t v_98 = seed.word(14); + row[layout.auxiliaries + 12] = v_97; + row[layout.auxiliaries + 13] = v_98; + row[layout.selectors + 10] = 1; + return 0; + } + case 10ULL: { + const uint64_t v_99 = seed.word(12); + const uint64_t v_100 = seed.word(13); + row[layout.auxiliaries + 11] = v_99; + row[layout.auxiliaries + 12] = v_100; + row[layout.selectors + 11] = 1; + return 0; + } + case 11ULL: { + const uint64_t v_103 = seed.word(12); + row[layout.auxiliaries + 11] = v_103; + row[layout.selectors + 12] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_95(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 160 : 280; + const Seed_ixvm_95 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_95(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_95(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_95<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_95<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_95(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 13 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 160 : encoding == 0 ? 280 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_95); +} + +template struct Seed_ixvm_100 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 152); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u8(data + 168); + case 11: return load_u64(data + 72); + case 12: return load_u32(data + 156); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + case 15: return load_u64(data + 96); + case 16: return load_u64(data + 104); + case 17: return load_u64(data + 112); + case 18: return load_u64(data + 120); + case 19: return load_u64(data + 128); + case 20: return load_u64(data + 136); + case 21: return load_u32(data + 160); + case 22: return load_u64(data + 144); + case 23: return load_u32(data + 164); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_100(Seed_ixvm_100 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_9; + switch (v_9) { + case 1ULL: { + const uint64_t v_11 = seed.word(11); + row[layout.auxiliaries + 2] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(11); + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 2] = v_12; + row[layout.auxiliaries + 3] = v_13; + const uint64_t v_14 = seed.word(13); + const uint64_t v_15 = seed.word(14); + const uint64_t v_16 = seed.word(15); + const uint64_t v_17 = seed.word(16); + const uint64_t v_18 = seed.word(17); + const uint64_t v_19 = seed.word(18); + const uint64_t v_20 = seed.word(19); + const uint64_t v_21 = seed.word(20); + row[layout.auxiliaries + 4] = v_14; + row[layout.auxiliaries + 5] = v_15; + row[layout.auxiliaries + 6] = v_16; + row[layout.auxiliaries + 7] = v_17; + row[layout.auxiliaries + 8] = v_18; + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + const uint64_t v_22 = seed.word(21); + const uint64_t v_23 = seed.word(22); + row[layout.auxiliaries + 12] = v_22; + row[layout.auxiliaries + 13] = v_23; + const uint64_t v_25 = seed.word(23); + row[layout.auxiliaries + 14] = v_25; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_100(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 192; + const Seed_ixvm_100 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_100(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_100(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_100<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_100<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_100(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 9 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 192 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_100); +} + +template struct Seed_ixvm_122 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 164); + case 2: return load_u32(data + 152); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + case 7: return load_u8(data + 165); + case 8: return load_u8(data + 166); + case 9: return load_u8(data + 167); + case 10: return load_u8(data + 168); + case 11: return load_u64(data + 40); + case 12: return load_u64(data + 48); + case 13: return load_u64(data + 56); + case 14: return load_u64(data + 64); + case 15: return load_u64(data + 72); + case 16: return load_u8(data + 169); + case 17: return load_u8(data + 170); + case 18: return load_u8(data + 171); + case 19: return load_u32(data + 156); + case 20: return load_u64(data + 80); + case 21: return load_u64(data + 88); + case 22: return load_u64(data + 96); + case 23: return load_u8(data + 172); + case 24: return load_u8(data + 173); + case 25: return load_u8(data + 174); + case 26: return load_u8(data + 175); + case 27: return load_u8(data + 176); + case 28: return load_u8(data + 177); + case 29: return load_u64(data + 104); + case 30: return load_u64(data + 112); + case 31: return load_u8(data + 178); + case 32: return load_u8(data + 179); + case 33: return load_u8(data + 180); + case 34: return load_u8(data + 181); + case 35: return load_u8(data + 182); + case 36: return load_u8(data + 183); + case 37: return load_u64(data + 120); + case 38: return load_u64(data + 128); + case 39: return load_u8(data + 184); + case 40: return load_u8(data + 185); + case 41: return load_u8(data + 186); + case 42: return load_u8(data + 187); + case 43: return load_u8(data + 188); + case 44: return load_u8(data + 189); + case 45: return load_u64(data + 136); + case 46: return load_u32(data + 160); + case 47: return load_u64(data + 144); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_122(Seed_ixvm_122 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_0) { + case 0ULL: { + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_16 = seed.word(3); + const uint64_t v_17 = seed.word(4); + const uint64_t v_18 = seed.word(5); + const uint64_t v_19 = seed.word(6); + const uint64_t v_20 = seed.word(7); + const uint64_t v_21 = seed.word(8); + const uint64_t v_22 = seed.word(9); + const uint64_t v_23 = seed.word(10); + const uint64_t v_24 = seed.word(11); + const uint64_t v_25 = seed.word(12); + const uint64_t v_26 = seed.word(13); + const uint64_t v_27 = seed.word(14); + const uint64_t v_28 = seed.word(15); + const uint64_t v_29 = seed.word(16); + const uint64_t v_30 = seed.word(17); + const uint64_t v_31 = seed.word(18); + const uint64_t v_32 = seed.word(19); + const uint64_t v_33 = seed.word(20); + const uint64_t v_34 = seed.word(21); + const uint64_t v_35 = seed.word(22); + const uint64_t v_36 = seed.word(23); + const uint64_t v_37 = seed.word(24); + const uint64_t v_38 = seed.word(25); + const uint64_t v_39 = seed.word(26); + const uint64_t v_40 = seed.word(27); + const uint64_t v_41 = seed.word(28); + const uint64_t v_42 = seed.word(29); + const uint64_t v_43 = seed.word(30); + const uint64_t v_44 = seed.word(31); + const uint64_t v_45 = seed.word(32); + const uint64_t v_46 = seed.word(33); + const uint64_t v_47 = seed.word(34); + const uint64_t v_48 = seed.word(35); + const uint64_t v_49 = seed.word(36); + const uint64_t v_50 = seed.word(37); + const uint64_t v_51 = seed.word(38); + const uint64_t v_52 = seed.word(39); + const uint64_t v_53 = seed.word(40); + const uint64_t v_54 = seed.word(41); + const uint64_t v_55 = seed.word(42); + const uint64_t v_56 = seed.word(43); + const uint64_t v_57 = seed.word(44); + const uint64_t v_58 = seed.word(45); + const uint64_t v_59 = seed.word(46); + const uint64_t v_60 = seed.word(47); + row[layout.auxiliaries + 1] = v_16; + row[layout.auxiliaries + 2] = v_17; + row[layout.auxiliaries + 3] = v_18; + row[layout.auxiliaries + 4] = v_19; + row[layout.auxiliaries + 5] = v_20; + row[layout.auxiliaries + 6] = v_21; + row[layout.auxiliaries + 7] = v_22; + row[layout.auxiliaries + 8] = v_23; + row[layout.auxiliaries + 9] = v_24; + row[layout.auxiliaries + 10] = v_25; + row[layout.auxiliaries + 11] = v_26; + row[layout.auxiliaries + 12] = v_27; + row[layout.auxiliaries + 13] = v_28; + row[layout.auxiliaries + 14] = v_29; + row[layout.auxiliaries + 15] = v_30; + row[layout.auxiliaries + 16] = v_31; + row[layout.auxiliaries + 17] = v_32; + row[layout.auxiliaries + 18] = v_33; + row[layout.auxiliaries + 19] = v_34; + row[layout.auxiliaries + 20] = v_35; + row[layout.auxiliaries + 21] = v_36; + row[layout.auxiliaries + 22] = v_37; + row[layout.auxiliaries + 23] = v_38; + row[layout.auxiliaries + 24] = v_39; + row[layout.auxiliaries + 25] = v_40; + row[layout.auxiliaries + 26] = v_41; + row[layout.auxiliaries + 27] = v_42; + row[layout.auxiliaries + 28] = v_43; + row[layout.auxiliaries + 29] = v_44; + row[layout.auxiliaries + 30] = v_45; + row[layout.auxiliaries + 31] = v_46; + row[layout.auxiliaries + 32] = v_47; + row[layout.auxiliaries + 33] = v_48; + row[layout.auxiliaries + 34] = v_49; + row[layout.auxiliaries + 35] = v_50; + row[layout.auxiliaries + 36] = v_51; + row[layout.auxiliaries + 37] = v_52; + row[layout.auxiliaries + 38] = v_53; + row[layout.auxiliaries + 39] = v_54; + row[layout.auxiliaries + 40] = v_55; + row[layout.auxiliaries + 41] = v_56; + row[layout.auxiliaries + 42] = v_57; + row[layout.auxiliaries + 43] = v_58; + row[layout.auxiliaries + 44] = v_59; + row[layout.auxiliaries + 45] = v_60; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_62 = seed.word(3); + const uint64_t v_63 = seed.word(4); + const uint64_t v_64 = seed.word(5); + const uint64_t v_65 = seed.word(6); + const uint64_t v_66 = seed.word(7); + const uint64_t v_67 = seed.word(8); + const uint64_t v_68 = seed.word(9); + const uint64_t v_69 = seed.word(10); + const uint64_t v_70 = seed.word(11); + const uint64_t v_71 = seed.word(12); + const uint64_t v_72 = seed.word(13); + row[layout.auxiliaries + 1] = v_62; + row[layout.auxiliaries + 2] = v_63; + row[layout.auxiliaries + 3] = v_64; + row[layout.auxiliaries + 4] = v_65; + row[layout.auxiliaries + 5] = v_66; + row[layout.auxiliaries + 6] = v_67; + row[layout.auxiliaries + 7] = v_68; + row[layout.auxiliaries + 8] = v_69; + row[layout.auxiliaries + 9] = v_70; + row[layout.auxiliaries + 10] = v_71; + row[layout.auxiliaries + 11] = v_72; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_75 = seed.word(3); + const uint64_t v_76 = seed.word(4); + const uint64_t v_77 = seed.word(5); + const uint64_t v_78 = seed.word(6); + const uint64_t v_79 = seed.word(7); + const uint64_t v_80 = seed.word(8); + const uint64_t v_81 = seed.word(9); + const uint64_t v_82 = seed.word(10); + const uint64_t v_83 = seed.word(11); + const uint64_t v_84 = seed.word(12); + const uint64_t v_85 = seed.word(13); + row[layout.auxiliaries + 1] = v_75; + row[layout.auxiliaries + 2] = v_76; + row[layout.auxiliaries + 3] = v_77; + row[layout.auxiliaries + 4] = v_78; + row[layout.auxiliaries + 5] = v_79; + row[layout.auxiliaries + 6] = v_80; + row[layout.auxiliaries + 7] = v_81; + row[layout.auxiliaries + 8] = v_82; + row[layout.auxiliaries + 9] = v_83; + row[layout.auxiliaries + 10] = v_84; + row[layout.auxiliaries + 11] = v_85; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_88 = seed.word(3); + const uint64_t v_89 = seed.word(4); + const uint64_t v_90 = seed.word(5); + const uint64_t v_91 = seed.word(6); + const uint64_t v_92 = seed.word(7); + const uint64_t v_93 = seed.word(8); + const uint64_t v_94 = seed.word(9); + const uint64_t v_95 = seed.word(10); + const uint64_t v_96 = seed.word(11); + const uint64_t v_97 = seed.word(12); + const uint64_t v_98 = seed.word(13); + const uint64_t v_99 = seed.word(14); + const uint64_t v_100 = seed.word(15); + const uint64_t v_101 = seed.word(16); + const uint64_t v_102 = seed.word(17); + const uint64_t v_103 = seed.word(18); + const uint64_t v_104 = seed.word(19); + const uint64_t v_105 = seed.word(20); + row[layout.auxiliaries + 1] = v_88; + row[layout.auxiliaries + 2] = v_89; + row[layout.auxiliaries + 3] = v_90; + row[layout.auxiliaries + 4] = v_91; + row[layout.auxiliaries + 5] = v_92; + row[layout.auxiliaries + 6] = v_93; + row[layout.auxiliaries + 7] = v_94; + row[layout.auxiliaries + 8] = v_95; + row[layout.auxiliaries + 9] = v_96; + row[layout.auxiliaries + 10] = v_97; + row[layout.auxiliaries + 11] = v_98; + row[layout.auxiliaries + 12] = v_99; + row[layout.auxiliaries + 13] = v_100; + row[layout.auxiliaries + 14] = v_101; + row[layout.auxiliaries + 15] = v_102; + row[layout.auxiliaries + 16] = v_103; + row[layout.auxiliaries + 17] = v_104; + row[layout.auxiliaries + 18] = v_105; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_108 = seed.word(3); + const uint64_t v_109 = seed.word(4); + const uint64_t v_110 = seed.word(5); + const uint64_t v_111 = seed.word(6); + const uint64_t v_112 = seed.word(7); + const uint64_t v_113 = seed.word(8); + const uint64_t v_114 = seed.word(9); + const uint64_t v_115 = seed.word(10); + const uint64_t v_116 = seed.word(11); + const uint64_t v_117 = seed.word(12); + row[layout.auxiliaries + 1] = v_108; + row[layout.auxiliaries + 2] = v_109; + row[layout.auxiliaries + 3] = v_110; + row[layout.auxiliaries + 4] = v_111; + row[layout.auxiliaries + 5] = v_112; + row[layout.auxiliaries + 6] = v_113; + row[layout.auxiliaries + 7] = v_114; + row[layout.auxiliaries + 8] = v_115; + row[layout.auxiliaries + 9] = v_116; + row[layout.auxiliaries + 10] = v_117; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_120 = seed.word(3); + const uint64_t v_121 = seed.word(4); + const uint64_t v_122 = seed.word(5); + const uint64_t v_123 = seed.word(6); + const uint64_t v_124 = seed.word(7); + const uint64_t v_125 = seed.word(8); + const uint64_t v_126 = seed.word(9); + const uint64_t v_127 = seed.word(10); + const uint64_t v_128 = seed.word(11); + const uint64_t v_129 = seed.word(12); + row[layout.auxiliaries + 1] = v_120; + row[layout.auxiliaries + 2] = v_121; + row[layout.auxiliaries + 3] = v_122; + row[layout.auxiliaries + 4] = v_123; + row[layout.auxiliaries + 5] = v_124; + row[layout.auxiliaries + 6] = v_125; + row[layout.auxiliaries + 7] = v_126; + row[layout.auxiliaries + 8] = v_127; + row[layout.auxiliaries + 9] = v_128; + row[layout.auxiliaries + 10] = v_129; + row[layout.selectors + 6] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_132 = seed.word(3); + const uint64_t v_133 = seed.word(4); + const uint64_t v_134 = seed.word(5); + const uint64_t v_135 = seed.word(6); + const uint64_t v_136 = seed.word(7); + const uint64_t v_137 = seed.word(8); + const uint64_t v_138 = seed.word(9); + const uint64_t v_139 = seed.word(10); + const uint64_t v_140 = seed.word(11); + const uint64_t v_141 = seed.word(12); + row[layout.auxiliaries + 1] = v_132; + row[layout.auxiliaries + 2] = v_133; + row[layout.auxiliaries + 3] = v_134; + row[layout.auxiliaries + 4] = v_135; + row[layout.auxiliaries + 5] = v_136; + row[layout.auxiliaries + 6] = v_137; + row[layout.auxiliaries + 7] = v_138; + row[layout.auxiliaries + 8] = v_139; + row[layout.auxiliaries + 9] = v_140; + row[layout.auxiliaries + 10] = v_141; + row[layout.selectors + 7] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_122(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 192 : 384; + const Seed_ixvm_122 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_122(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_122(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_122<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_122<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_122(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 46) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 192 : encoding == 0 ? 384 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_122); +} + +__device__ __constant__ uint64_t inverse_125_0[] = {6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_125 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u8(data + 48); + case 3: return load_u32(data + 36); + case 4: return load_u64(data + 8); + case 5: return load_u64(data + 16); + case 6: return load_u64(data + 24); + case 7: return load_u32(data + 40); + case 8: return load_u32(data + 44); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_125(Seed_ixvm_125 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + switch (v_1) { + case 3ULL: { + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 7] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 5] = (v_1 <= 3ULL ? inverse_125_0[v_1] : inverse(goldilocks_sub(v_1, 3ULL))); + const uint64_t v_9 = seed.word(6); + row[layout.auxiliaries + 6] = v_9; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_125(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 72; + const Seed_ixvm_125 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_125(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_125(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_125<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_125<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_125(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 72 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_125); +} + +__device__ __constant__ uint64_t inverse_127_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_127_1[] = {0ULL}; +template struct Seed_ixvm_127 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u8(data + 44); + case 4: return load_u8(data + 45); + case 5: return load_u8(data + 46); + case 6: return load_u8(data + 47); + case 7: return load_u8(data + 48); + case 8: return load_u8(data + 49); + case 9: return load_u8(data + 50); + case 10: return load_u8(data + 51); + case 11: return load_u8(data + 52); + case 12: return load_u8(data + 53); + case 13: return load_u32(data + 24); + case 14: return load_u32(data + 28); + case 15: return load_u8(data + 54); + case 16: return load_u8(data + 55); + case 17: return load_u8(data + 56); + case 18: return load_u8(data + 57); + case 19: return load_u8(data + 58); + case 20: return load_u8(data + 59); + case 21: return load_u8(data + 60); + case 22: return load_u8(data + 61); + case 23: return load_u32(data + 32); + case 24: return load_u32(data + 36); + case 25: return load_u8(data + 62); + case 26: return load_u8(data + 63); + case 27: return load_u8(data + 64); + case 28: return load_u8(data + 65); + case 29: return load_u8(data + 66); + case 30: return load_u8(data + 67); + case 31: return load_u8(data + 68); + case 32: return load_u8(data + 69); + case 33: return load_u8(data + 70); + case 34: return load_u8(data + 71); + case 35: return load_u8(data + 72); + case 36: return load_u8(data + 73); + case 37: return load_u8(data + 74); + case 38: return load_u8(data + 75); + case 39: return load_u8(data + 76); + case 40: return load_u8(data + 77); + case 41: return load_u8(data + 78); + case 42: return load_u64(data + 8); + case 43: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_127(Seed_ixvm_127 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + switch (v_3) { + case 1ULL: { + switch (v_2) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 11] = (v_2 <= 0ULL ? inverse_127_0[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 12] = v_13; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + case 0ULL: { + const uint64_t v_14 = seed.word(14); + const uint64_t v_15 = seed.word(15); + const uint64_t v_16 = seed.word(16); + const uint64_t v_17 = seed.word(17); + const uint64_t v_18 = seed.word(18); + const uint64_t v_19 = seed.word(19); + const uint64_t v_20 = seed.word(20); + const uint64_t v_21 = seed.word(21); + const uint64_t v_22 = seed.word(22); + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + row[layout.auxiliaries + 16] = v_19; + row[layout.auxiliaries + 17] = v_20; + row[layout.auxiliaries + 18] = v_21; + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + switch (v_14) { + case 1ULL: { + switch (v_2) { + case 0ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 21] = (v_2 <= 0ULL ? inverse_127_1[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 22] = v_24; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + case 0ULL: { + const uint64_t v_25 = seed.word(24); + const uint64_t v_26 = seed.word(25); + const uint64_t v_27 = seed.word(26); + const uint64_t v_28 = seed.word(27); + const uint64_t v_29 = seed.word(28); + const uint64_t v_30 = seed.word(29); + const uint64_t v_31 = seed.word(30); + const uint64_t v_32 = seed.word(31); + const uint64_t v_33 = seed.word(32); + row[layout.auxiliaries + 21] = v_25; + row[layout.auxiliaries + 22] = v_26; + row[layout.auxiliaries + 23] = v_27; + row[layout.auxiliaries + 24] = v_28; + row[layout.auxiliaries + 25] = v_29; + row[layout.auxiliaries + 26] = v_30; + row[layout.auxiliaries + 27] = v_31; + row[layout.auxiliaries + 28] = v_32; + row[layout.auxiliaries + 29] = v_33; + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + row[layout.auxiliaries + 30] = v_35; + row[layout.auxiliaries + 31] = v_36; + row[layout.auxiliaries + 32] = v_37; + row[layout.auxiliaries + 33] = v_38; + row[layout.auxiliaries + 34] = v_39; + row[layout.auxiliaries + 35] = v_40; + row[layout.auxiliaries + 36] = v_41; + row[layout.auxiliaries + 37] = v_42; + row[layout.auxiliaries + 38] = v_43; + const uint64_t v_45 = seed.word(42); + row[layout.auxiliaries + 39] = v_45; + const uint64_t v_46 = seed.word(43); + row[layout.auxiliaries + 40] = v_46; + row[layout.selectors + 4] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_127(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 80 : 352; + const Seed_ixvm_127 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_127(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_127(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_127<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_127<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_127(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 41) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 352 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_127); +} + +template struct Seed_ixvm_132 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u8(data + 36); + case 3: return load_u8(data + 37); + case 4: return load_u8(data + 38); + case 5: return load_u8(data + 39); + case 6: return load_u8(data + 40); + case 7: return load_u8(data + 41); + case 8: return load_u8(data + 42); + case 9: return load_u8(data + 43); + case 10: return load_u8(data + 44); + case 11: return load_u32(data + 20); + case 12: return load_u32(data + 24); + case 13: return load_u32(data + 28); + case 14: return load_u64(data + 8); + case 15: return load_u32(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_132(Seed_ixvm_132 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + switch (v_1) { + case 1ULL: { + const uint64_t v_12 = seed.word(12); + row[layout.auxiliaries + 11] = v_12; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 13] = v_16; + const uint64_t v_18 = seed.word(15); + row[layout.auxiliaries + 14] = v_18; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_132(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 128; + const Seed_ixvm_132 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_132(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_132(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_132<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_132<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_132(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 15) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 128 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_132); +} + +template struct Seed_ixvm_140 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u32(data + 24); + case 4: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_140(Seed_ixvm_140 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 2] = v_5; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_140(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 40; + const Seed_ixvm_140 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_140(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_140(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_140<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_140<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_140(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_140); +} + +__device__ __constant__ uint64_t inverse_142_0[] = {0ULL}; +template struct Seed_ixvm_142 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u64(data + 64); + case 9: return load_u32(data + 136); + case 10: return load_u8(data + 168); + case 11: return load_u8(data + 169); + case 12: return load_u8(data + 170); + case 13: return load_u8(data + 171); + case 14: return load_u8(data + 172); + case 15: return load_u8(data + 173); + case 16: return load_u8(data + 174); + case 17: return load_u8(data + 175); + case 18: return load_u8(data + 176); + case 19: return load_u64(data + 72); + case 20: return load_u64(data + 80); + case 21: return load_u64(data + 88); + case 22: return load_u64(data + 96); + case 23: return load_u64(data + 104); + case 24: return load_u64(data + 112); + case 25: return load_u64(data + 120); + case 26: return load_u64(data + 128); + case 27: return load_u32(data + 140); + case 28: return load_u8(data + 177); + case 29: return load_u32(data + 144); + case 30: return load_u32(data + 148); + case 31: return load_u8(data + 178); + case 32: return load_u8(data + 179); + case 33: return load_u8(data + 180); + case 34: return load_u8(data + 181); + case 35: return load_u8(data + 182); + case 36: return load_u8(data + 183); + case 37: return load_u8(data + 184); + case 38: return load_u8(data + 185); + case 39: return load_u8(data + 186); + case 40: return load_u8(data + 187); + case 41: return load_u8(data + 188); + case 42: return load_u8(data + 189); + case 43: return load_u8(data + 190); + case 44: return load_u8(data + 191); + case 45: return load_u8(data + 192); + case 46: return load_u8(data + 193); + case 47: return load_u8(data + 194); + case 48: return load_u8(data + 195); + case 49: return load_u8(data + 196); + case 50: return load_u8(data + 197); + case 51: return load_u8(data + 198); + case 52: return load_u8(data + 199); + case 53: return load_u32(data + 152); + case 54: return load_u32(data + 156); + case 55: return load_u8(data + 200); + case 56: return load_u8(data + 201); + case 57: return load_u8(data + 202); + case 58: return load_u8(data + 203); + case 59: return load_u8(data + 204); + case 60: return load_u8(data + 205); + case 61: return load_u32(data + 160); + case 62: return load_u32(data + 164); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_142(Seed_ixvm_142 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + row[layout.auxiliaries + 1] = v_17; + row[layout.auxiliaries + 2] = v_18; + row[layout.auxiliaries + 3] = v_19; + row[layout.auxiliaries + 4] = v_20; + row[layout.auxiliaries + 5] = v_21; + row[layout.auxiliaries + 6] = v_22; + row[layout.auxiliaries + 7] = v_23; + row[layout.auxiliaries + 8] = v_24; + row[layout.auxiliaries + 9] = v_25; + row[layout.auxiliaries + 10] = v_26; + switch (v_17) { + case 1ULL: { + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 11] = v_27; + switch (v_27) { + case 1ULL: { + const uint64_t v_29 = seed.word(29); + row[layout.auxiliaries + 12] = v_29; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_32 = seed.word(29); + row[layout.auxiliaries + 12] = v_32; + const uint64_t v_33 = seed.word(30); + row[layout.auxiliaries + 13] = v_33; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 0ULL: { + const uint64_t v_34 = seed.word(28); + const uint64_t v_35 = seed.word(29); + const uint64_t v_36 = seed.word(30); + const uint64_t v_37 = seed.word(31); + const uint64_t v_38 = seed.word(32); + const uint64_t v_39 = seed.word(33); + const uint64_t v_40 = seed.word(34); + const uint64_t v_41 = seed.word(35); + const uint64_t v_42 = seed.word(36); + const uint64_t v_43 = seed.word(37); + const uint64_t v_44 = seed.word(38); + const uint64_t v_45 = seed.word(39); + const uint64_t v_46 = seed.word(40); + const uint64_t v_47 = seed.word(41); + const uint64_t v_48 = seed.word(42); + const uint64_t v_49 = seed.word(43); + row[layout.auxiliaries + 11] = v_34; + row[layout.auxiliaries + 12] = v_35; + row[layout.auxiliaries + 13] = v_36; + row[layout.auxiliaries + 14] = v_37; + row[layout.auxiliaries + 15] = v_38; + row[layout.auxiliaries + 16] = v_39; + row[layout.auxiliaries + 17] = v_40; + row[layout.auxiliaries + 18] = v_41; + row[layout.auxiliaries + 19] = v_42; + row[layout.auxiliaries + 20] = v_43; + row[layout.auxiliaries + 21] = v_44; + row[layout.auxiliaries + 22] = v_45; + row[layout.auxiliaries + 23] = v_46; + row[layout.auxiliaries + 24] = v_47; + row[layout.auxiliaries + 25] = v_48; + row[layout.auxiliaries + 26] = v_49; + const uint64_t v_50 = seed.word(44); + const uint64_t v_51 = seed.word(45); + const uint64_t v_52 = seed.word(46); + const uint64_t v_53 = seed.word(47); + const uint64_t v_54 = seed.word(48); + const uint64_t v_55 = seed.word(49); + const uint64_t v_56 = seed.word(50); + const uint64_t v_57 = seed.word(51); + const uint64_t v_58 = seed.word(52); + row[layout.auxiliaries + 27] = v_50; + row[layout.auxiliaries + 28] = v_51; + row[layout.auxiliaries + 29] = v_52; + row[layout.auxiliaries + 30] = v_53; + row[layout.auxiliaries + 31] = v_54; + row[layout.auxiliaries + 32] = v_55; + row[layout.auxiliaries + 33] = v_56; + row[layout.auxiliaries + 34] = v_57; + row[layout.auxiliaries + 35] = v_58; + switch (v_58) { + case 0ULL: { + const uint64_t v_60 = seed.word(53); + row[layout.auxiliaries + 36] = v_60; + const uint64_t v_61 = seed.word(54); + row[layout.auxiliaries + 37] = v_61; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 36] = (v_58 <= 0ULL ? inverse_142_0[v_58] : inverse(goldilocks_sub(v_58, 0ULL))); + const uint64_t v_63 = seed.word(53); + const uint64_t v_64 = seed.word(54); + const uint64_t v_65 = seed.word(55); + const uint64_t v_66 = seed.word(56); + const uint64_t v_67 = seed.word(57); + const uint64_t v_68 = seed.word(58); + const uint64_t v_69 = seed.word(59); + const uint64_t v_70 = seed.word(60); + row[layout.auxiliaries + 37] = v_63; + row[layout.auxiliaries + 38] = v_64; + row[layout.auxiliaries + 39] = v_65; + row[layout.auxiliaries + 40] = v_66; + row[layout.auxiliaries + 41] = v_67; + row[layout.auxiliaries + 42] = v_68; + row[layout.auxiliaries + 43] = v_69; + row[layout.auxiliaries + 44] = v_70; + const uint64_t v_71 = seed.word(61); + row[layout.auxiliaries + 45] = v_71; + const uint64_t v_72 = seed.word(62); + row[layout.auxiliaries + 46] = v_72; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_142(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 208 : 504; + const Seed_ixvm_142 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_142(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_142(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_142<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_142<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_142(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 17 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 47) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 208 : encoding == 0 ? 504 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_142); +} + +template struct Seed_ixvm_151 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + case 13: return load_u8(data + 20); + case 14: return load_u8(data + 21); + case 15: return load_u8(data + 22); + case 16: return load_u8(data + 23); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_151(Seed_ixvm_151 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + if (v_0 > 255 || v_8 > 255) return 1; + const uint64_t v_16 = (v_0 | v_8); + row[layout.auxiliaries + 1] = v_16; + if (v_1 > 255 || v_9 > 255) return 1; + const uint64_t v_17 = (v_1 | v_9); + row[layout.auxiliaries + 2] = v_17; + if (v_2 > 255 || v_10 > 255) return 1; + const uint64_t v_18 = (v_2 | v_10); + row[layout.auxiliaries + 3] = v_18; + if (v_3 > 255 || v_11 > 255) return 1; + const uint64_t v_19 = (v_3 | v_11); + row[layout.auxiliaries + 4] = v_19; + if (v_4 > 255 || v_12 > 255) return 1; + const uint64_t v_20 = (v_4 | v_12); + row[layout.auxiliaries + 5] = v_20; + if (v_5 > 255 || v_13 > 255) return 1; + const uint64_t v_21 = (v_5 | v_13); + row[layout.auxiliaries + 6] = v_21; + if (v_6 > 255 || v_14 > 255) return 1; + const uint64_t v_22 = (v_6 | v_14); + row[layout.auxiliaries + 7] = v_22; + if (v_7 > 255 || v_15 > 255) return 1; + const uint64_t v_23 = (v_7 | v_15); + row[layout.auxiliaries + 8] = v_23; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_151(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 136; + const Seed_ixvm_151 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_151(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_151(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_151<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_151<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_151(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_151); +} + +template struct Seed_ixvm_152 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 8); + case 2: return load_u8(data + 9); + case 3: return load_u8(data + 10); + case 4: return load_u8(data + 11); + case 5: return load_u8(data + 12); + case 6: return load_u8(data + 13); + case 7: return load_u8(data + 14); + case 8: return load_u8(data + 15); + case 9: return load_u8(data + 16); + case 10: return load_u8(data + 17); + case 11: return load_u8(data + 18); + case 12: return load_u8(data + 19); + case 13: return load_u8(data + 20); + case 14: return load_u8(data + 21); + case 15: return load_u8(data + 22); + case 16: return load_u8(data + 23); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_152(Seed_ixvm_152 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + if (v_0 > 255 || v_8 > 255) return 1; + const uint64_t v_16 = (v_0 ^ v_8); + row[layout.auxiliaries + 1] = v_16; + if (v_1 > 255 || v_9 > 255) return 1; + const uint64_t v_17 = (v_1 ^ v_9); + row[layout.auxiliaries + 2] = v_17; + if (v_2 > 255 || v_10 > 255) return 1; + const uint64_t v_18 = (v_2 ^ v_10); + row[layout.auxiliaries + 3] = v_18; + if (v_3 > 255 || v_11 > 255) return 1; + const uint64_t v_19 = (v_3 ^ v_11); + row[layout.auxiliaries + 4] = v_19; + if (v_4 > 255 || v_12 > 255) return 1; + const uint64_t v_20 = (v_4 ^ v_12); + row[layout.auxiliaries + 5] = v_20; + if (v_5 > 255 || v_13 > 255) return 1; + const uint64_t v_21 = (v_5 ^ v_13); + row[layout.auxiliaries + 6] = v_21; + if (v_6 > 255 || v_14 > 255) return 1; + const uint64_t v_22 = (v_6 ^ v_14); + row[layout.auxiliaries + 7] = v_22; + if (v_7 > 255 || v_15 > 255) return 1; + const uint64_t v_23 = (v_7 ^ v_15); + row[layout.auxiliaries + 8] = v_23; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_152(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 136; + const Seed_ixvm_152 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_152(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_152(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_152<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_152<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_152(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_152); +} + +template struct Seed_ixvm_154 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u8(data + 36); + case 4: return load_u8(data + 37); + case 5: return load_u8(data + 38); + case 6: return load_u8(data + 39); + case 7: return load_u8(data + 40); + case 8: return load_u8(data + 41); + case 9: return load_u8(data + 42); + case 10: return load_u8(data + 43); + case 11: return load_u8(data + 44); + case 12: return load_u32(data + 24); + case 13: return load_u8(data + 45); + case 14: return load_u8(data + 46); + case 15: return load_u8(data + 47); + case 16: return load_u8(data + 48); + case 17: return load_u8(data + 49); + case 18: return load_u8(data + 50); + case 19: return load_u8(data + 51); + case 20: return load_u8(data + 52); + case 21: return load_u8(data + 53); + case 22: return load_u32(data + 28); + case 23: return load_u8(data + 54); + case 24: return load_u8(data + 55); + case 25: return load_u8(data + 56); + case 26: return load_u8(data + 57); + case 27: return load_u8(data + 58); + case 28: return load_u8(data + 59); + case 29: return load_u8(data + 60); + case 30: return load_u8(data + 61); + case 31: return load_u64(data + 8); + case 32: return load_u32(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_154(Seed_ixvm_154 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + switch (v_12) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_23 = seed.word(23); + const uint64_t v_24 = seed.word(24); + const uint64_t v_25 = seed.word(25); + const uint64_t v_26 = seed.word(26); + const uint64_t v_27 = seed.word(27); + const uint64_t v_28 = seed.word(28); + const uint64_t v_29 = seed.word(29); + const uint64_t v_30 = seed.word(30); + row[layout.auxiliaries + 21] = v_23; + row[layout.auxiliaries + 22] = v_24; + row[layout.auxiliaries + 23] = v_25; + row[layout.auxiliaries + 24] = v_26; + row[layout.auxiliaries + 25] = v_27; + row[layout.auxiliaries + 26] = v_28; + row[layout.auxiliaries + 27] = v_29; + row[layout.auxiliaries + 28] = v_30; + const uint64_t v_31 = seed.word(31); + row[layout.auxiliaries + 29] = v_31; + const uint64_t v_32 = seed.word(32); + row[layout.auxiliaries + 30] = v_32; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_154(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 264; + const Seed_ixvm_154 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_154(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_154(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_154<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_154<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_154(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 31) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_154); +} + +template struct Seed_ixvm_155 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u8(data + 36); + case 4: return load_u8(data + 37); + case 5: return load_u8(data + 38); + case 6: return load_u8(data + 39); + case 7: return load_u8(data + 40); + case 8: return load_u8(data + 41); + case 9: return load_u8(data + 42); + case 10: return load_u8(data + 43); + case 11: return load_u8(data + 44); + case 12: return load_u32(data + 24); + case 13: return load_u8(data + 45); + case 14: return load_u8(data + 46); + case 15: return load_u8(data + 47); + case 16: return load_u8(data + 48); + case 17: return load_u8(data + 49); + case 18: return load_u8(data + 50); + case 19: return load_u8(data + 51); + case 20: return load_u8(data + 52); + case 21: return load_u8(data + 53); + case 22: return load_u32(data + 28); + case 23: return load_u8(data + 54); + case 24: return load_u8(data + 55); + case 25: return load_u8(data + 56); + case 26: return load_u8(data + 57); + case 27: return load_u8(data + 58); + case 28: return load_u8(data + 59); + case 29: return load_u8(data + 60); + case 30: return load_u8(data + 61); + case 31: return load_u64(data + 8); + case 32: return load_u32(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_155(Seed_ixvm_155 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + switch (v_12) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_23 = seed.word(23); + const uint64_t v_24 = seed.word(24); + const uint64_t v_25 = seed.word(25); + const uint64_t v_26 = seed.word(26); + const uint64_t v_27 = seed.word(27); + const uint64_t v_28 = seed.word(28); + const uint64_t v_29 = seed.word(29); + const uint64_t v_30 = seed.word(30); + row[layout.auxiliaries + 21] = v_23; + row[layout.auxiliaries + 22] = v_24; + row[layout.auxiliaries + 23] = v_25; + row[layout.auxiliaries + 24] = v_26; + row[layout.auxiliaries + 25] = v_27; + row[layout.auxiliaries + 26] = v_28; + row[layout.auxiliaries + 27] = v_29; + row[layout.auxiliaries + 28] = v_30; + const uint64_t v_31 = seed.word(31); + row[layout.auxiliaries + 29] = v_31; + const uint64_t v_32 = seed.word(32); + row[layout.auxiliaries + 30] = v_32; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_155(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 264; + const Seed_ixvm_155 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_155(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_155(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_155<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_155<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_155(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 31) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_155); +} + +__device__ __constant__ uint64_t inverse_230_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_230_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_230_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_230_3[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_230_4[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_230_5[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_230_6[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_230 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 40); + case 4: return load_u32(data + 16); + case 5: return load_u8(data + 41); + case 6: return load_u32(data + 20); + case 7: return load_u8(data + 42); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 43); + case 10: return load_u32(data + 28); + case 11: return load_u8(data + 44); + case 12: return load_u32(data + 32); + case 13: return load_u8(data + 45); + case 14: return load_u32(data + 36); + case 15: return load_u8(data + 46); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_230(Seed_ixvm_230 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 2] = v_2; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_2 <= 1ULL ? inverse_230_0[v_2] : inverse(goldilocks_sub(v_2, 1ULL))); + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 4] = v_4; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 5] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_5 <= 1ULL ? inverse_230_1[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 7] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 8] = v_8; + switch (v_8) { + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_230_2[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 11] = v_11; + switch (v_11) { + case 1ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_11 <= 1ULL ? inverse_230_3[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(10); + row[layout.auxiliaries + 13] = v_13; + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 14] = v_14; + switch (v_14) { + case 1ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 15] = (v_14 <= 1ULL ? inverse_230_4[v_14] : inverse(goldilocks_sub(v_14, 1ULL))); + const uint64_t v_16 = seed.word(12); + row[layout.auxiliaries + 16] = v_16; + const uint64_t v_17 = seed.word(13); + row[layout.auxiliaries + 17] = v_17; + switch (v_17) { + case 1ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 18] = (v_17 <= 1ULL ? inverse_230_5[v_17] : inverse(goldilocks_sub(v_17, 1ULL))); + const uint64_t v_19 = seed.word(14); + row[layout.auxiliaries + 19] = v_19; + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 20] = v_20; + switch (v_20) { + case 1ULL: { + row[layout.selectors + 6] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 21] = (v_20 <= 1ULL ? inverse_230_6[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + } + } + } + } + } + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_230(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 128; + const Seed_ixvm_230 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_230(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_230(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_230<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_230<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_230(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 128 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_230); +} + +__device__ __constant__ uint64_t inverse_241_0[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_241_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_241_2[] = {9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_241_3[] = {6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_241 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 128); + case 2: return load_u32(data + 132); + case 3: return load_u8(data + 176); + case 4: return load_u32(data + 136); + case 5: return load_u32(data + 140); + case 6: return load_u64(data + 8); + case 7: return load_u8(data + 177); + case 8: return load_u32(data + 144); + case 9: return load_u64(data + 16); + case 10: return load_u64(data + 24); + case 11: return load_u32(data + 148); + case 12: return load_u8(data + 178); + case 13: return load_u64(data + 32); + case 14: return load_u32(data + 152); + case 15: return load_u32(data + 156); + case 16: return load_u64(data + 40); + case 17: return load_u64(data + 48); + case 18: return load_u64(data + 56); + case 19: return load_u64(data + 64); + case 20: return load_u64(data + 72); + case 21: return load_u64(data + 80); + case 22: return load_u64(data + 88); + case 23: return load_u64(data + 96); + case 24: return load_u32(data + 160); + case 25: return load_u32(data + 164); + case 26: return load_u8(data + 179); + case 27: return load_u64(data + 104); + case 28: return load_u32(data + 168); + case 29: return load_u64(data + 112); + case 30: return load_u32(data + 172); + case 31: return load_u64(data + 120); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_241(Seed_ixvm_241 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_2) { + case 3ULL: { + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + switch (v_6) { + case 2ULL: { + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 9] = v_10; + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + switch (v_11) { + case 1ULL: { + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 22] = v_24; + const uint64_t v_25 = seed.word(25); + row[layout.auxiliaries + 23] = v_25; + const uint64_t v_26 = seed.word(26); + const uint64_t v_27 = seed.word(27); + const uint64_t v_28 = seed.word(28); + const uint64_t v_29 = seed.word(29); + row[layout.auxiliaries + 24] = v_26; + row[layout.auxiliaries + 25] = v_27; + row[layout.auxiliaries + 26] = v_28; + row[layout.auxiliaries + 27] = v_29; + switch (v_26) { + case 4ULL: { + const uint64_t v_31 = seed.word(30); + row[layout.auxiliaries + 28] = v_31; + const uint64_t v_32 = seed.word(31); + row[layout.auxiliaries + 29] = v_32; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 28] = (v_26 <= 4ULL ? inverse_241_0[v_26] : inverse(goldilocks_sub(v_26, 4ULL))); + const uint64_t v_35 = seed.word(30); + row[layout.auxiliaries + 29] = v_35; + const uint64_t v_36 = seed.word(31); + row[layout.auxiliaries + 30] = v_36; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 22] = (v_11 <= 1ULL ? inverse_241_1[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_6 <= 2ULL ? inverse_241_2[v_6] : inverse(goldilocks_sub(v_6, 2ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 5] = (v_2 <= 3ULL ? inverse_241_3[v_2] : inverse(goldilocks_sub(v_2, 3ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_241(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 184 : 256; + const Seed_ixvm_241 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_241(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_241(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_241<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_241<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_241(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 31) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 256 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_241); +} + +template struct Seed_ixvm_266 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 32); + case 3: return load_u8(data + 44); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 36); + case 6: return load_u32(data + 40); + case 7: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_266(Seed_ixvm_266 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 4] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 5] = v_8; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_266(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_266 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_266(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_266(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_266<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_266<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_266(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_266); +} + +__device__ __constant__ uint64_t inverse_297_0[] = {0ULL}; +template struct Seed_ixvm_297 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 104); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u64(data + 80); + case 12: return load_u64(data + 88); + case 13: return load_u32(data + 96); + case 14: return load_u8(data + 105); + case 15: return load_u8(data + 106); + case 16: return load_u32(data + 100); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_297(Seed_ixvm_297 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + switch (v_0) { + default: { + const uint64_t v_14 = seed.word(15); + row[layout.auxiliaries + 1] = v_14; + switch (v_14) { + case 0ULL: { + const uint64_t v_16 = seed.word(16); + row[layout.auxiliaries + 2] = v_16; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_14 <= 0ULL ? inverse_297_0[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); + const uint64_t v_17 = seed.word(16); + row[layout.auxiliaries + 3] = v_17; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + } +} +template __global__ void kernel_ixvm_297(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 112 : 136; + const Seed_ixvm_297 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_297(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_297(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_297<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_297<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_297(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 14 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_297); +} + +template struct Seed_ixvm_300 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 336); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 337); + case 4: return load_u32(data + 288); + case 5: return load_u64(data + 16); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u8(data + 338); + case 9: return load_u8(data + 339); + case 10: return load_u8(data + 340); + case 11: return load_u8(data + 341); + case 12: return load_u64(data + 40); + case 13: return load_u64(data + 48); + case 14: return load_u64(data + 56); + case 15: return load_u64(data + 64); + case 16: return load_u8(data + 342); + case 17: return load_u8(data + 343); + case 18: return load_u8(data + 344); + case 19: return load_u8(data + 345); + case 20: return load_u32(data + 292); + case 21: return load_u8(data + 346); + case 22: return load_u64(data + 72); + case 23: return load_u64(data + 80); + case 24: return load_u8(data + 347); + case 25: return load_u8(data + 348); + case 26: return load_u8(data + 349); + case 27: return load_u8(data + 350); + case 28: return load_u8(data + 351); + case 29: return load_u8(data + 352); + case 30: return load_u64(data + 88); + case 31: return load_u64(data + 96); + case 32: return load_u8(data + 353); + case 33: return load_u8(data + 354); + case 34: return load_u8(data + 355); + case 35: return load_u8(data + 356); + case 36: return load_u8(data + 357); + case 37: return load_u8(data + 358); + case 38: return load_u64(data + 104); + case 39: return load_u64(data + 112); + case 40: return load_u8(data + 359); + case 41: return load_u8(data + 360); + case 42: return load_u8(data + 361); + case 43: return load_u8(data + 362); + case 44: return load_u8(data + 363); + case 45: return load_u8(data + 364); + case 46: return load_u64(data + 120); + case 47: return load_u32(data + 296); + case 48: return load_u32(data + 300); + case 49: return load_u32(data + 304); + case 50: return load_u32(data + 308); + case 51: return load_u8(data + 365); + case 52: return load_u8(data + 366); + case 53: return load_u64(data + 128); + case 54: return load_u64(data + 136); + case 55: return load_u64(data + 144); + case 56: return load_u8(data + 367); + case 57: return load_u8(data + 368); + case 58: return load_u8(data + 369); + case 59: return load_u8(data + 370); + case 60: return load_u8(data + 371); + case 61: return load_u64(data + 152); + case 62: return load_u64(data + 160); + case 63: return load_u64(data + 168); + case 64: return load_u8(data + 372); + case 65: return load_u8(data + 373); + case 66: return load_u8(data + 374); + case 67: return load_u8(data + 375); + case 68: return load_u8(data + 376); + case 69: return load_u64(data + 176); + case 70: return load_u64(data + 184); + case 71: return load_u64(data + 192); + case 72: return load_u8(data + 377); + case 73: return load_u8(data + 378); + case 74: return load_u8(data + 379); + case 75: return load_u8(data + 380); + case 76: return load_u8(data + 381); + case 77: return load_u32(data + 312); + case 78: return load_u32(data + 316); + case 79: return load_u64(data + 200); + case 80: return load_u8(data + 382); + case 81: return load_u8(data + 383); + case 82: return load_u8(data + 384); + case 83: return load_u8(data + 385); + case 84: return load_u8(data + 386); + case 85: return load_u8(data + 387); + case 86: return load_u64(data + 208); + case 87: return load_u64(data + 216); + case 88: return load_u8(data + 388); + case 89: return load_u8(data + 389); + case 90: return load_u8(data + 390); + case 91: return load_u8(data + 391); + case 92: return load_u8(data + 392); + case 93: return load_u8(data + 393); + case 94: return load_u64(data + 224); + case 95: return load_u32(data + 320); + case 96: return load_u32(data + 324); + case 97: return load_u8(data + 394); + case 98: return load_u64(data + 232); + case 99: return load_u32(data + 328); + case 100: return load_u64(data + 240); + case 101: return load_u64(data + 248); + case 102: return load_u64(data + 256); + case 103: return load_u64(data + 264); + case 104: return load_u64(data + 272); + case 105: return load_u64(data + 280); + case 106: return load_u8(data + 395); + case 107: return load_u8(data + 396); + case 108: return load_u8(data + 397); + case 109: return load_u32(data + 332); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_300(Seed_ixvm_300 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.auxiliaries + 27] = v_28; + row[layout.auxiliaries + 28] = v_29; + row[layout.auxiliaries + 29] = v_30; + row[layout.auxiliaries + 30] = v_31; + row[layout.auxiliaries + 31] = v_32; + row[layout.auxiliaries + 32] = v_33; + row[layout.auxiliaries + 33] = v_34; + row[layout.auxiliaries + 34] = v_35; + row[layout.auxiliaries + 35] = v_36; + row[layout.auxiliaries + 36] = v_37; + row[layout.auxiliaries + 37] = v_38; + row[layout.auxiliaries + 38] = v_39; + row[layout.auxiliaries + 39] = v_40; + row[layout.auxiliaries + 40] = v_41; + row[layout.auxiliaries + 41] = v_42; + row[layout.auxiliaries + 42] = v_43; + row[layout.auxiliaries + 43] = v_44; + row[layout.auxiliaries + 44] = v_45; + row[layout.auxiliaries + 45] = v_46; + row[layout.auxiliaries + 46] = v_47; + row[layout.auxiliaries + 47] = v_48; + row[layout.auxiliaries + 48] = v_49; + switch (v_2) { + default: { + switch (v_2) { + case 8ULL: { + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + const uint64_t v_67 = seed.word(68); + const uint64_t v_68 = seed.word(69); + const uint64_t v_69 = seed.word(70); + const uint64_t v_70 = seed.word(71); + const uint64_t v_71 = seed.word(72); + const uint64_t v_72 = seed.word(73); + const uint64_t v_73 = seed.word(74); + const uint64_t v_74 = seed.word(75); + const uint64_t v_75 = seed.word(76); + const uint64_t v_76 = seed.word(77); + const uint64_t v_77 = seed.word(78); + const uint64_t v_78 = seed.word(79); + const uint64_t v_79 = seed.word(80); + const uint64_t v_80 = seed.word(81); + const uint64_t v_81 = seed.word(82); + const uint64_t v_82 = seed.word(83); + const uint64_t v_83 = seed.word(84); + const uint64_t v_84 = seed.word(85); + const uint64_t v_85 = seed.word(86); + const uint64_t v_86 = seed.word(87); + const uint64_t v_87 = seed.word(88); + const uint64_t v_88 = seed.word(89); + const uint64_t v_89 = seed.word(90); + const uint64_t v_90 = seed.word(91); + const uint64_t v_91 = seed.word(92); + const uint64_t v_92 = seed.word(93); + const uint64_t v_93 = seed.word(94); + const uint64_t v_94 = seed.word(95); + row[layout.auxiliaries + 49] = v_50; + row[layout.auxiliaries + 50] = v_51; + row[layout.auxiliaries + 51] = v_52; + row[layout.auxiliaries + 52] = v_53; + row[layout.auxiliaries + 53] = v_54; + row[layout.auxiliaries + 54] = v_55; + row[layout.auxiliaries + 55] = v_56; + row[layout.auxiliaries + 56] = v_57; + row[layout.auxiliaries + 57] = v_58; + row[layout.auxiliaries + 58] = v_59; + row[layout.auxiliaries + 59] = v_60; + row[layout.auxiliaries + 60] = v_61; + row[layout.auxiliaries + 61] = v_62; + row[layout.auxiliaries + 62] = v_63; + row[layout.auxiliaries + 63] = v_64; + row[layout.auxiliaries + 64] = v_65; + row[layout.auxiliaries + 65] = v_66; + row[layout.auxiliaries + 66] = v_67; + row[layout.auxiliaries + 67] = v_68; + row[layout.auxiliaries + 68] = v_69; + row[layout.auxiliaries + 69] = v_70; + row[layout.auxiliaries + 70] = v_71; + row[layout.auxiliaries + 71] = v_72; + row[layout.auxiliaries + 72] = v_73; + row[layout.auxiliaries + 73] = v_74; + row[layout.auxiliaries + 74] = v_75; + row[layout.auxiliaries + 75] = v_76; + row[layout.auxiliaries + 76] = v_77; + row[layout.auxiliaries + 77] = v_78; + row[layout.auxiliaries + 78] = v_79; + row[layout.auxiliaries + 79] = v_80; + row[layout.auxiliaries + 80] = v_81; + row[layout.auxiliaries + 81] = v_82; + row[layout.auxiliaries + 82] = v_83; + row[layout.auxiliaries + 83] = v_84; + row[layout.auxiliaries + 84] = v_85; + row[layout.auxiliaries + 85] = v_86; + row[layout.auxiliaries + 86] = v_87; + row[layout.auxiliaries + 87] = v_88; + row[layout.auxiliaries + 88] = v_89; + row[layout.auxiliaries + 89] = v_90; + row[layout.auxiliaries + 90] = v_91; + row[layout.auxiliaries + 91] = v_92; + row[layout.auxiliaries + 92] = v_93; + row[layout.auxiliaries + 93] = v_94; + switch (v_50) { + case 1ULL: { + const uint64_t v_95 = seed.word(96); + row[layout.auxiliaries + 94] = v_95; + const uint64_t v_96 = seed.word(97); + const uint64_t v_97 = seed.word(98); + const uint64_t v_98 = seed.word(99); + const uint64_t v_99 = seed.word(100); + const uint64_t v_100 = seed.word(101); + const uint64_t v_101 = seed.word(102); + const uint64_t v_102 = seed.word(103); + const uint64_t v_103 = seed.word(104); + const uint64_t v_104 = seed.word(105); + const uint64_t v_105 = seed.word(106); + const uint64_t v_106 = seed.word(107); + const uint64_t v_107 = seed.word(108); + row[layout.auxiliaries + 95] = v_96; + row[layout.auxiliaries + 96] = v_97; + row[layout.auxiliaries + 97] = v_98; + row[layout.auxiliaries + 98] = v_99; + row[layout.auxiliaries + 99] = v_100; + row[layout.auxiliaries + 100] = v_101; + row[layout.auxiliaries + 101] = v_102; + row[layout.auxiliaries + 102] = v_103; + row[layout.auxiliaries + 103] = v_104; + row[layout.auxiliaries + 104] = v_105; + row[layout.auxiliaries + 105] = v_106; + row[layout.auxiliaries + 106] = v_107; + const uint64_t v_108 = seed.word(109); + row[layout.auxiliaries + 107] = v_108; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_300(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 400 : 880; + const Seed_ixvm_300 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_300(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_300(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_300<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_300<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_300(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 108) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 400 : encoding == 0 ? 880 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_300); +} + +template struct Seed_ixvm_301 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 424); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u8(data + 425); + case 5: return load_u32(data + 376); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u64(data + 40); + case 9: return load_u8(data + 426); + case 10: return load_u8(data + 427); + case 11: return load_u8(data + 428); + case 12: return load_u8(data + 429); + case 13: return load_u64(data + 48); + case 14: return load_u64(data + 56); + case 15: return load_u64(data + 64); + case 16: return load_u64(data + 72); + case 17: return load_u8(data + 430); + case 18: return load_u8(data + 431); + case 19: return load_u8(data + 432); + case 20: return load_u8(data + 433); + case 21: return load_u32(data + 380); + case 22: return load_u8(data + 434); + case 23: return load_u64(data + 80); + case 24: return load_u64(data + 88); + case 25: return load_u8(data + 435); + case 26: return load_u8(data + 436); + case 27: return load_u8(data + 437); + case 28: return load_u8(data + 438); + case 29: return load_u8(data + 439); + case 30: return load_u8(data + 440); + case 31: return load_u64(data + 96); + case 32: return load_u64(data + 104); + case 33: return load_u8(data + 441); + case 34: return load_u8(data + 442); + case 35: return load_u8(data + 443); + case 36: return load_u8(data + 444); + case 37: return load_u8(data + 445); + case 38: return load_u8(data + 446); + case 39: return load_u64(data + 112); + case 40: return load_u64(data + 120); + case 41: return load_u8(data + 447); + case 42: return load_u8(data + 448); + case 43: return load_u8(data + 449); + case 44: return load_u8(data + 450); + case 45: return load_u8(data + 451); + case 46: return load_u8(data + 452); + case 47: return load_u64(data + 128); + case 48: return load_u32(data + 384); + case 49: return load_u32(data + 388); + case 50: return load_u32(data + 392); + case 51: return load_u32(data + 396); + case 52: return load_u8(data + 453); + case 53: return load_u8(data + 454); + case 54: return load_u64(data + 136); + case 55: return load_u64(data + 144); + case 56: return load_u64(data + 152); + case 57: return load_u8(data + 455); + case 58: return load_u8(data + 456); + case 59: return load_u8(data + 457); + case 60: return load_u8(data + 458); + case 61: return load_u8(data + 459); + case 62: return load_u64(data + 160); + case 63: return load_u64(data + 168); + case 64: return load_u64(data + 176); + case 65: return load_u8(data + 460); + case 66: return load_u8(data + 461); + case 67: return load_u8(data + 462); + case 68: return load_u8(data + 463); + case 69: return load_u8(data + 464); + case 70: return load_u64(data + 184); + case 71: return load_u64(data + 192); + case 72: return load_u64(data + 200); + case 73: return load_u8(data + 465); + case 74: return load_u8(data + 466); + case 75: return load_u8(data + 467); + case 76: return load_u8(data + 468); + case 77: return load_u8(data + 469); + case 78: return load_u64(data + 208); + case 79: return load_u32(data + 400); + case 80: return load_u64(data + 216); + case 81: return load_u8(data + 470); + case 82: return load_u8(data + 471); + case 83: return load_u8(data + 472); + case 84: return load_u8(data + 473); + case 85: return load_u8(data + 474); + case 86: return load_u8(data + 475); + case 87: return load_u64(data + 224); + case 88: return load_u64(data + 232); + case 89: return load_u8(data + 476); + case 90: return load_u8(data + 477); + case 91: return load_u8(data + 478); + case 92: return load_u8(data + 479); + case 93: return load_u8(data + 480); + case 94: return load_u8(data + 481); + case 95: return load_u64(data + 240); + case 96: return load_u32(data + 404); + case 97: return load_u64(data + 248); + case 98: return load_u64(data + 256); + case 99: return load_u64(data + 264); + case 100: return load_u8(data + 482); + case 101: return load_u8(data + 483); + case 102: return load_u8(data + 484); + case 103: return load_u8(data + 485); + case 104: return load_u8(data + 486); + case 105: return load_u8(data + 487); + case 106: return load_u64(data + 272); + case 107: return load_u64(data + 280); + case 108: return load_u8(data + 488); + case 109: return load_u8(data + 489); + case 110: return load_u8(data + 490); + case 111: return load_u8(data + 491); + case 112: return load_u8(data + 492); + case 113: return load_u8(data + 493); + case 114: return load_u64(data + 288); + case 115: return load_u64(data + 296); + case 116: return load_u8(data + 494); + case 117: return load_u8(data + 495); + case 118: return load_u8(data + 496); + case 119: return load_u8(data + 497); + case 120: return load_u8(data + 498); + case 121: return load_u8(data + 499); + case 122: return load_u64(data + 304); + case 123: return load_u64(data + 312); + case 124: return load_u8(data + 500); + case 125: return load_u8(data + 501); + case 126: return load_u8(data + 502); + case 127: return load_u8(data + 503); + case 128: return load_u8(data + 504); + case 129: return load_u8(data + 505); + case 130: return load_u32(data + 408); + case 131: return load_u32(data + 412); + case 132: return load_u8(data + 506); + case 133: return load_u64(data + 320); + case 134: return load_u32(data + 416); + case 135: return load_u64(data + 328); + case 136: return load_u64(data + 336); + case 137: return load_u64(data + 344); + case 138: return load_u64(data + 352); + case 139: return load_u64(data + 360); + case 140: return load_u64(data + 368); + case 141: return load_u8(data + 507); + case 142: return load_u8(data + 508); + case 143: return load_u8(data + 509); + case 144: return load_u32(data + 420); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_301(Seed_ixvm_301 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + row[layout.auxiliaries + 11] = v_13; + row[layout.auxiliaries + 12] = v_14; + row[layout.auxiliaries + 13] = v_15; + row[layout.auxiliaries + 14] = v_16; + row[layout.auxiliaries + 15] = v_17; + row[layout.auxiliaries + 16] = v_18; + row[layout.auxiliaries + 17] = v_19; + row[layout.auxiliaries + 18] = v_20; + row[layout.auxiliaries + 19] = v_21; + row[layout.auxiliaries + 20] = v_22; + row[layout.auxiliaries + 21] = v_23; + row[layout.auxiliaries + 22] = v_24; + row[layout.auxiliaries + 23] = v_25; + row[layout.auxiliaries + 24] = v_26; + row[layout.auxiliaries + 25] = v_27; + row[layout.auxiliaries + 26] = v_28; + row[layout.auxiliaries + 27] = v_29; + row[layout.auxiliaries + 28] = v_30; + row[layout.auxiliaries + 29] = v_31; + row[layout.auxiliaries + 30] = v_32; + row[layout.auxiliaries + 31] = v_33; + row[layout.auxiliaries + 32] = v_34; + row[layout.auxiliaries + 33] = v_35; + row[layout.auxiliaries + 34] = v_36; + row[layout.auxiliaries + 35] = v_37; + row[layout.auxiliaries + 36] = v_38; + row[layout.auxiliaries + 37] = v_39; + row[layout.auxiliaries + 38] = v_40; + row[layout.auxiliaries + 39] = v_41; + row[layout.auxiliaries + 40] = v_42; + row[layout.auxiliaries + 41] = v_43; + row[layout.auxiliaries + 42] = v_44; + row[layout.auxiliaries + 43] = v_45; + row[layout.auxiliaries + 44] = v_46; + row[layout.auxiliaries + 45] = v_47; + row[layout.auxiliaries + 46] = v_48; + row[layout.auxiliaries + 47] = v_49; + row[layout.auxiliaries + 48] = v_50; + switch (v_3) { + default: { + switch (v_3) { + case 8ULL: { + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + const uint64_t v_67 = seed.word(68); + const uint64_t v_68 = seed.word(69); + const uint64_t v_69 = seed.word(70); + const uint64_t v_70 = seed.word(71); + const uint64_t v_71 = seed.word(72); + const uint64_t v_72 = seed.word(73); + const uint64_t v_73 = seed.word(74); + const uint64_t v_74 = seed.word(75); + const uint64_t v_75 = seed.word(76); + const uint64_t v_76 = seed.word(77); + const uint64_t v_77 = seed.word(78); + const uint64_t v_78 = seed.word(79); + const uint64_t v_79 = seed.word(80); + const uint64_t v_80 = seed.word(81); + const uint64_t v_81 = seed.word(82); + const uint64_t v_82 = seed.word(83); + const uint64_t v_83 = seed.word(84); + const uint64_t v_84 = seed.word(85); + const uint64_t v_85 = seed.word(86); + const uint64_t v_86 = seed.word(87); + const uint64_t v_87 = seed.word(88); + const uint64_t v_88 = seed.word(89); + const uint64_t v_89 = seed.word(90); + const uint64_t v_90 = seed.word(91); + const uint64_t v_91 = seed.word(92); + const uint64_t v_92 = seed.word(93); + const uint64_t v_93 = seed.word(94); + const uint64_t v_94 = seed.word(95); + const uint64_t v_95 = seed.word(96); + row[layout.auxiliaries + 49] = v_51; + row[layout.auxiliaries + 50] = v_52; + row[layout.auxiliaries + 51] = v_53; + row[layout.auxiliaries + 52] = v_54; + row[layout.auxiliaries + 53] = v_55; + row[layout.auxiliaries + 54] = v_56; + row[layout.auxiliaries + 55] = v_57; + row[layout.auxiliaries + 56] = v_58; + row[layout.auxiliaries + 57] = v_59; + row[layout.auxiliaries + 58] = v_60; + row[layout.auxiliaries + 59] = v_61; + row[layout.auxiliaries + 60] = v_62; + row[layout.auxiliaries + 61] = v_63; + row[layout.auxiliaries + 62] = v_64; + row[layout.auxiliaries + 63] = v_65; + row[layout.auxiliaries + 64] = v_66; + row[layout.auxiliaries + 65] = v_67; + row[layout.auxiliaries + 66] = v_68; + row[layout.auxiliaries + 67] = v_69; + row[layout.auxiliaries + 68] = v_70; + row[layout.auxiliaries + 69] = v_71; + row[layout.auxiliaries + 70] = v_72; + row[layout.auxiliaries + 71] = v_73; + row[layout.auxiliaries + 72] = v_74; + row[layout.auxiliaries + 73] = v_75; + row[layout.auxiliaries + 74] = v_76; + row[layout.auxiliaries + 75] = v_77; + row[layout.auxiliaries + 76] = v_78; + row[layout.auxiliaries + 77] = v_79; + row[layout.auxiliaries + 78] = v_80; + row[layout.auxiliaries + 79] = v_81; + row[layout.auxiliaries + 80] = v_82; + row[layout.auxiliaries + 81] = v_83; + row[layout.auxiliaries + 82] = v_84; + row[layout.auxiliaries + 83] = v_85; + row[layout.auxiliaries + 84] = v_86; + row[layout.auxiliaries + 85] = v_87; + row[layout.auxiliaries + 86] = v_88; + row[layout.auxiliaries + 87] = v_89; + row[layout.auxiliaries + 88] = v_90; + row[layout.auxiliaries + 89] = v_91; + row[layout.auxiliaries + 90] = v_92; + row[layout.auxiliaries + 91] = v_93; + row[layout.auxiliaries + 92] = v_94; + row[layout.auxiliaries + 93] = v_95; + switch (v_51) { + case 1ULL: { + switch (v_52) { + default: { + const uint64_t v_96 = seed.word(97); + const uint64_t v_97 = seed.word(98); + const uint64_t v_98 = seed.word(99); + const uint64_t v_99 = seed.word(100); + const uint64_t v_100 = seed.word(101); + const uint64_t v_101 = seed.word(102); + const uint64_t v_102 = seed.word(103); + const uint64_t v_103 = seed.word(104); + const uint64_t v_104 = seed.word(105); + const uint64_t v_105 = seed.word(106); + const uint64_t v_106 = seed.word(107); + const uint64_t v_107 = seed.word(108); + const uint64_t v_108 = seed.word(109); + const uint64_t v_109 = seed.word(110); + const uint64_t v_110 = seed.word(111); + const uint64_t v_111 = seed.word(112); + const uint64_t v_112 = seed.word(113); + const uint64_t v_113 = seed.word(114); + const uint64_t v_114 = seed.word(115); + const uint64_t v_115 = seed.word(116); + const uint64_t v_116 = seed.word(117); + const uint64_t v_117 = seed.word(118); + const uint64_t v_118 = seed.word(119); + const uint64_t v_119 = seed.word(120); + const uint64_t v_120 = seed.word(121); + const uint64_t v_121 = seed.word(122); + const uint64_t v_122 = seed.word(123); + const uint64_t v_123 = seed.word(124); + const uint64_t v_124 = seed.word(125); + const uint64_t v_125 = seed.word(126); + const uint64_t v_126 = seed.word(127); + const uint64_t v_127 = seed.word(128); + const uint64_t v_128 = seed.word(129); + const uint64_t v_129 = seed.word(130); + row[layout.auxiliaries + 94] = v_96; + row[layout.auxiliaries + 95] = v_97; + row[layout.auxiliaries + 96] = v_98; + row[layout.auxiliaries + 97] = v_99; + row[layout.auxiliaries + 98] = v_100; + row[layout.auxiliaries + 99] = v_101; + row[layout.auxiliaries + 100] = v_102; + row[layout.auxiliaries + 101] = v_103; + row[layout.auxiliaries + 102] = v_104; + row[layout.auxiliaries + 103] = v_105; + row[layout.auxiliaries + 104] = v_106; + row[layout.auxiliaries + 105] = v_107; + row[layout.auxiliaries + 106] = v_108; + row[layout.auxiliaries + 107] = v_109; + row[layout.auxiliaries + 108] = v_110; + row[layout.auxiliaries + 109] = v_111; + row[layout.auxiliaries + 110] = v_112; + row[layout.auxiliaries + 111] = v_113; + row[layout.auxiliaries + 112] = v_114; + row[layout.auxiliaries + 113] = v_115; + row[layout.auxiliaries + 114] = v_116; + row[layout.auxiliaries + 115] = v_117; + row[layout.auxiliaries + 116] = v_118; + row[layout.auxiliaries + 117] = v_119; + row[layout.auxiliaries + 118] = v_120; + row[layout.auxiliaries + 119] = v_121; + row[layout.auxiliaries + 120] = v_122; + row[layout.auxiliaries + 121] = v_123; + row[layout.auxiliaries + 122] = v_124; + row[layout.auxiliaries + 123] = v_125; + row[layout.auxiliaries + 124] = v_126; + row[layout.auxiliaries + 125] = v_127; + row[layout.auxiliaries + 126] = v_128; + row[layout.auxiliaries + 127] = v_129; + const uint64_t v_130 = seed.word(131); + row[layout.auxiliaries + 128] = v_130; + const uint64_t v_131 = seed.word(132); + const uint64_t v_132 = seed.word(133); + const uint64_t v_133 = seed.word(134); + const uint64_t v_134 = seed.word(135); + const uint64_t v_135 = seed.word(136); + const uint64_t v_136 = seed.word(137); + const uint64_t v_137 = seed.word(138); + const uint64_t v_138 = seed.word(139); + const uint64_t v_139 = seed.word(140); + const uint64_t v_140 = seed.word(141); + const uint64_t v_141 = seed.word(142); + const uint64_t v_142 = seed.word(143); + row[layout.auxiliaries + 129] = v_131; + row[layout.auxiliaries + 130] = v_132; + row[layout.auxiliaries + 131] = v_133; + row[layout.auxiliaries + 132] = v_134; + row[layout.auxiliaries + 133] = v_135; + row[layout.auxiliaries + 134] = v_136; + row[layout.auxiliaries + 135] = v_137; + row[layout.auxiliaries + 136] = v_138; + row[layout.auxiliaries + 137] = v_139; + row[layout.auxiliaries + 138] = v_140; + row[layout.auxiliaries + 139] = v_141; + row[layout.auxiliaries + 140] = v_142; + const uint64_t v_143 = seed.word(144); + row[layout.auxiliaries + 141] = v_143; + row[layout.selectors + 0] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_301(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 512 : 1160; + const Seed_ixvm_301 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_301(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_301(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_301<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_301<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_301(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 142) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 512 : encoding == 0 ? 1160 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_301); +} + +__device__ __constant__ uint64_t inverse_303_0[] = {0ULL}; +template struct Seed_ixvm_303 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 256); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 272); + case 4: return load_u8(data + 273); + case 5: return load_u8(data + 274); + case 6: return load_u64(data + 16); + case 7: return load_u64(data + 24); + case 8: return load_u64(data + 32); + case 9: return load_u8(data + 275); + case 10: return load_u8(data + 276); + case 11: return load_u8(data + 277); + case 12: return load_u8(data + 278); + case 13: return load_u8(data + 279); + case 14: return load_u64(data + 40); + case 15: return load_u64(data + 48); + case 16: return load_u64(data + 56); + case 17: return load_u8(data + 280); + case 18: return load_u8(data + 281); + case 19: return load_u8(data + 282); + case 20: return load_u8(data + 283); + case 21: return load_u8(data + 284); + case 22: return load_u64(data + 64); + case 23: return load_u64(data + 72); + case 24: return load_u64(data + 80); + case 25: return load_u8(data + 285); + case 26: return load_u8(data + 286); + case 27: return load_u8(data + 287); + case 28: return load_u8(data + 288); + case 29: return load_u8(data + 289); + case 30: return load_u64(data + 88); + case 31: return load_u64(data + 96); + case 32: return load_u64(data + 104); + case 33: return load_u8(data + 290); + case 34: return load_u8(data + 291); + case 35: return load_u8(data + 292); + case 36: return load_u8(data + 293); + case 37: return load_u8(data + 294); + case 38: return load_u8(data + 295); + case 39: return load_u64(data + 112); + case 40: return load_u64(data + 120); + case 41: return load_u8(data + 296); + case 42: return load_u8(data + 297); + case 43: return load_u8(data + 298); + case 44: return load_u8(data + 299); + case 45: return load_u8(data + 300); + case 46: return load_u8(data + 301); + case 47: return load_u64(data + 128); + case 48: return load_u32(data + 260); + case 49: return load_u32(data + 264); + case 50: return load_u8(data + 302); + case 51: return load_u8(data + 303); + case 52: return load_u64(data + 136); + case 53: return load_u64(data + 144); + case 54: return load_u64(data + 152); + case 55: return load_u8(data + 304); + case 56: return load_u8(data + 305); + case 57: return load_u8(data + 306); + case 58: return load_u8(data + 307); + case 59: return load_u8(data + 308); + case 60: return load_u64(data + 160); + case 61: return load_u64(data + 168); + case 62: return load_u64(data + 176); + case 63: return load_u8(data + 309); + case 64: return load_u8(data + 310); + case 65: return load_u8(data + 311); + case 66: return load_u8(data + 312); + case 67: return load_u8(data + 313); + case 68: return load_u64(data + 184); + case 69: return load_u64(data + 192); + case 70: return load_u64(data + 200); + case 71: return load_u8(data + 314); + case 72: return load_u8(data + 315); + case 73: return load_u8(data + 316); + case 74: return load_u8(data + 317); + case 75: return load_u8(data + 318); + case 76: return load_u64(data + 208); + case 77: return load_u64(data + 216); + case 78: return load_u64(data + 224); + case 79: return load_u8(data + 319); + case 80: return load_u8(data + 320); + case 81: return load_u8(data + 321); + case 82: return load_u8(data + 322); + case 83: return load_u8(data + 323); + case 84: return load_u8(data + 324); + case 85: return load_u64(data + 232); + case 86: return load_u64(data + 240); + case 87: return load_u8(data + 325); + case 88: return load_u8(data + 326); + case 89: return load_u8(data + 327); + case 90: return load_u8(data + 328); + case 91: return load_u8(data + 329); + case 92: return load_u8(data + 330); + case 93: return load_u64(data + 248); + case 94: return load_u32(data + 268); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_303(Seed_ixvm_303 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.auxiliaries + 27] = v_28; + row[layout.auxiliaries + 28] = v_29; + row[layout.auxiliaries + 29] = v_30; + row[layout.auxiliaries + 30] = v_31; + row[layout.auxiliaries + 31] = v_32; + row[layout.auxiliaries + 32] = v_33; + row[layout.auxiliaries + 33] = v_34; + row[layout.auxiliaries + 34] = v_35; + row[layout.auxiliaries + 35] = v_36; + row[layout.auxiliaries + 36] = v_37; + row[layout.auxiliaries + 37] = v_38; + row[layout.auxiliaries + 38] = v_39; + row[layout.auxiliaries + 39] = v_40; + row[layout.auxiliaries + 40] = v_41; + row[layout.auxiliaries + 41] = v_42; + row[layout.auxiliaries + 42] = v_43; + row[layout.auxiliaries + 43] = v_44; + row[layout.auxiliaries + 44] = v_45; + row[layout.auxiliaries + 45] = v_46; + row[layout.auxiliaries + 46] = v_47; + row[layout.auxiliaries + 47] = v_48; + switch (v_2) { + case 0ULL: { + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 48] = (v_1 <= 0ULL ? inverse_303_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_51 = seed.word(50); + const uint64_t v_52 = seed.word(51); + const uint64_t v_53 = seed.word(52); + const uint64_t v_54 = seed.word(53); + const uint64_t v_55 = seed.word(54); + const uint64_t v_56 = seed.word(55); + const uint64_t v_57 = seed.word(56); + const uint64_t v_58 = seed.word(57); + const uint64_t v_59 = seed.word(58); + const uint64_t v_60 = seed.word(59); + const uint64_t v_61 = seed.word(60); + const uint64_t v_62 = seed.word(61); + const uint64_t v_63 = seed.word(62); + const uint64_t v_64 = seed.word(63); + const uint64_t v_65 = seed.word(64); + const uint64_t v_66 = seed.word(65); + const uint64_t v_67 = seed.word(66); + const uint64_t v_68 = seed.word(67); + const uint64_t v_69 = seed.word(68); + const uint64_t v_70 = seed.word(69); + const uint64_t v_71 = seed.word(70); + const uint64_t v_72 = seed.word(71); + const uint64_t v_73 = seed.word(72); + const uint64_t v_74 = seed.word(73); + const uint64_t v_75 = seed.word(74); + const uint64_t v_76 = seed.word(75); + const uint64_t v_77 = seed.word(76); + const uint64_t v_78 = seed.word(77); + const uint64_t v_79 = seed.word(78); + const uint64_t v_80 = seed.word(79); + const uint64_t v_81 = seed.word(80); + const uint64_t v_82 = seed.word(81); + const uint64_t v_83 = seed.word(82); + const uint64_t v_84 = seed.word(83); + const uint64_t v_85 = seed.word(84); + const uint64_t v_86 = seed.word(85); + const uint64_t v_87 = seed.word(86); + const uint64_t v_88 = seed.word(87); + const uint64_t v_89 = seed.word(88); + const uint64_t v_90 = seed.word(89); + const uint64_t v_91 = seed.word(90); + const uint64_t v_92 = seed.word(91); + const uint64_t v_93 = seed.word(92); + const uint64_t v_94 = seed.word(93); + const uint64_t v_95 = seed.word(94); + row[layout.auxiliaries + 49] = v_51; + row[layout.auxiliaries + 50] = v_52; + row[layout.auxiliaries + 51] = v_53; + row[layout.auxiliaries + 52] = v_54; + row[layout.auxiliaries + 53] = v_55; + row[layout.auxiliaries + 54] = v_56; + row[layout.auxiliaries + 55] = v_57; + row[layout.auxiliaries + 56] = v_58; + row[layout.auxiliaries + 57] = v_59; + row[layout.auxiliaries + 58] = v_60; + row[layout.auxiliaries + 59] = v_61; + row[layout.auxiliaries + 60] = v_62; + row[layout.auxiliaries + 61] = v_63; + row[layout.auxiliaries + 62] = v_64; + row[layout.auxiliaries + 63] = v_65; + row[layout.auxiliaries + 64] = v_66; + row[layout.auxiliaries + 65] = v_67; + row[layout.auxiliaries + 66] = v_68; + row[layout.auxiliaries + 67] = v_69; + row[layout.auxiliaries + 68] = v_70; + row[layout.auxiliaries + 69] = v_71; + row[layout.auxiliaries + 70] = v_72; + row[layout.auxiliaries + 71] = v_73; + row[layout.auxiliaries + 72] = v_74; + row[layout.auxiliaries + 73] = v_75; + row[layout.auxiliaries + 74] = v_76; + row[layout.auxiliaries + 75] = v_77; + row[layout.auxiliaries + 76] = v_78; + row[layout.auxiliaries + 77] = v_79; + row[layout.auxiliaries + 78] = v_80; + row[layout.auxiliaries + 79] = v_81; + row[layout.auxiliaries + 80] = v_82; + row[layout.auxiliaries + 81] = v_83; + row[layout.auxiliaries + 82] = v_84; + row[layout.auxiliaries + 83] = v_85; + row[layout.auxiliaries + 84] = v_86; + row[layout.auxiliaries + 85] = v_87; + row[layout.auxiliaries + 86] = v_88; + row[layout.auxiliaries + 87] = v_89; + row[layout.auxiliaries + 88] = v_90; + row[layout.auxiliaries + 89] = v_91; + row[layout.auxiliaries + 90] = v_92; + row[layout.auxiliaries + 91] = v_93; + row[layout.auxiliaries + 92] = v_94; + row[layout.auxiliaries + 93] = v_95; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_303(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 336 : 760; + const Seed_ixvm_303 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_303(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_303(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_303<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_303<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_303(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 94) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 336 : encoding == 0 ? 760 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_303); +} + +template struct Seed_ixvm_305 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 136); + case 2: return load_u8(data + 156); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 157); + case 5: return load_u8(data + 158); + case 6: return load_u64(data + 16); + case 7: return load_u64(data + 24); + case 8: return load_u64(data + 32); + case 9: return load_u8(data + 159); + case 10: return load_u8(data + 160); + case 11: return load_u8(data + 161); + case 12: return load_u8(data + 162); + case 13: return load_u8(data + 163); + case 14: return load_u64(data + 40); + case 15: return load_u64(data + 48); + case 16: return load_u64(data + 56); + case 17: return load_u8(data + 164); + case 18: return load_u8(data + 165); + case 19: return load_u8(data + 166); + case 20: return load_u8(data + 167); + case 21: return load_u8(data + 168); + case 22: return load_u64(data + 64); + case 23: return load_u64(data + 72); + case 24: return load_u64(data + 80); + case 25: return load_u8(data + 169); + case 26: return load_u8(data + 170); + case 27: return load_u8(data + 171); + case 28: return load_u8(data + 172); + case 29: return load_u8(data + 173); + case 30: return load_u64(data + 88); + case 31: return load_u64(data + 96); + case 32: return load_u64(data + 104); + case 33: return load_u8(data + 174); + case 34: return load_u8(data + 175); + case 35: return load_u8(data + 176); + case 36: return load_u8(data + 177); + case 37: return load_u8(data + 178); + case 38: return load_u8(data + 179); + case 39: return load_u64(data + 112); + case 40: return load_u64(data + 120); + case 41: return load_u8(data + 180); + case 42: return load_u8(data + 181); + case 43: return load_u8(data + 182); + case 44: return load_u8(data + 183); + case 45: return load_u8(data + 184); + case 46: return load_u8(data + 185); + case 47: return load_u64(data + 128); + case 48: return load_u32(data + 140); + case 49: return load_u8(data + 186); + case 50: return load_u8(data + 187); + case 51: return load_u8(data + 188); + case 52: return load_u8(data + 189); + case 53: return load_u8(data + 190); + case 54: return load_u8(data + 191); + case 55: return load_u8(data + 192); + case 56: return load_u8(data + 193); + case 57: return load_u32(data + 144); + case 58: return load_u32(data + 148); + case 59: return load_u32(data + 152); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_305(Seed_ixvm_305 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + row[layout.auxiliaries + 11] = v_13; + row[layout.auxiliaries + 12] = v_14; + row[layout.auxiliaries + 13] = v_15; + row[layout.auxiliaries + 14] = v_16; + row[layout.auxiliaries + 15] = v_17; + row[layout.auxiliaries + 16] = v_18; + row[layout.auxiliaries + 17] = v_19; + row[layout.auxiliaries + 18] = v_20; + row[layout.auxiliaries + 19] = v_21; + row[layout.auxiliaries + 20] = v_22; + row[layout.auxiliaries + 21] = v_23; + row[layout.auxiliaries + 22] = v_24; + row[layout.auxiliaries + 23] = v_25; + row[layout.auxiliaries + 24] = v_26; + row[layout.auxiliaries + 25] = v_27; + row[layout.auxiliaries + 26] = v_28; + row[layout.auxiliaries + 27] = v_29; + row[layout.auxiliaries + 28] = v_30; + row[layout.auxiliaries + 29] = v_31; + row[layout.auxiliaries + 30] = v_32; + row[layout.auxiliaries + 31] = v_33; + row[layout.auxiliaries + 32] = v_34; + row[layout.auxiliaries + 33] = v_35; + row[layout.auxiliaries + 34] = v_36; + row[layout.auxiliaries + 35] = v_37; + row[layout.auxiliaries + 36] = v_38; + row[layout.auxiliaries + 37] = v_39; + row[layout.auxiliaries + 38] = v_40; + row[layout.auxiliaries + 39] = v_41; + row[layout.auxiliaries + 40] = v_42; + row[layout.auxiliaries + 41] = v_43; + row[layout.auxiliaries + 42] = v_44; + row[layout.auxiliaries + 43] = v_45; + row[layout.auxiliaries + 44] = v_46; + row[layout.auxiliaries + 45] = v_47; + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + row[layout.auxiliaries + 46] = v_48; + row[layout.auxiliaries + 47] = v_49; + row[layout.auxiliaries + 48] = v_50; + row[layout.auxiliaries + 49] = v_51; + row[layout.auxiliaries + 50] = v_52; + row[layout.auxiliaries + 51] = v_53; + row[layout.auxiliaries + 52] = v_54; + row[layout.auxiliaries + 53] = v_55; + uint64_t v_62; + uint64_t v_63; + uint64_t v_64; + uint64_t v_65; + uint64_t v_66; + uint64_t v_67; + uint64_t v_68; + uint64_t v_69; + uint64_t v_70; + uint64_t v_71; + uint64_t v_72; + uint64_t v_73; + uint64_t v_74; + uint64_t v_75; + uint64_t v_76; + uint64_t v_77; + uint64_t v_78; + uint64_t v_79; + uint64_t v_80; + uint64_t v_81; + uint64_t v_82; + uint64_t v_83; + uint64_t v_84; + uint64_t v_85; + uint64_t v_86; + uint64_t v_87; + uint64_t v_88; + uint64_t v_89; + uint64_t v_90; + uint64_t v_91; + uint64_t v_92; + uint64_t v_93; + uint64_t v_94; + uint64_t v_95; + uint64_t v_96; + uint64_t v_97; + uint64_t v_98; + uint64_t v_99; + uint64_t v_100; + uint64_t v_101; + uint64_t v_102; + uint64_t v_103; + uint64_t v_104; + uint64_t v_105; + uint64_t v_106; + switch (v_3) { + case 0ULL: { + const uint64_t v_56 = 7ULL; + const uint64_t v_57 = 0ULL; + row[layout.selectors + 0] = 1; + v_62 = v_56; + v_63 = v_48; + v_64 = v_49; + v_65 = v_50; + v_66 = v_51; + v_67 = v_52; + v_68 = v_53; + v_69 = v_54; + v_70 = v_55; + v_71 = v_1; + v_72 = v_57; + v_73 = v_57; + v_74 = v_57; + v_75 = v_57; + v_76 = v_57; + v_77 = v_57; + v_78 = v_57; + v_79 = v_57; + v_80 = v_57; + v_81 = v_57; + v_82 = v_57; + v_83 = v_57; + v_84 = v_57; + v_85 = v_57; + v_86 = v_57; + v_87 = v_57; + v_88 = v_57; + v_89 = v_57; + v_90 = v_57; + v_91 = v_57; + v_92 = v_57; + v_93 = v_57; + v_94 = v_57; + v_95 = v_57; + v_96 = v_57; + v_97 = v_57; + v_98 = v_57; + v_99 = v_57; + v_100 = v_57; + v_101 = v_57; + v_102 = v_57; + v_103 = v_57; + v_104 = v_57; + v_105 = v_57; + v_106 = v_57; + goto continuation_0; + } + case 1ULL: { + const uint64_t v_58 = 6ULL; + const uint64_t v_59 = 0ULL; + row[layout.selectors + 1] = 1; + v_62 = v_58; + v_63 = v_48; + v_64 = v_49; + v_65 = v_50; + v_66 = v_51; + v_67 = v_52; + v_68 = v_53; + v_69 = v_54; + v_70 = v_55; + v_71 = v_1; + v_72 = v_59; + v_73 = v_59; + v_74 = v_59; + v_75 = v_59; + v_76 = v_59; + v_77 = v_59; + v_78 = v_59; + v_79 = v_59; + v_80 = v_59; + v_81 = v_59; + v_82 = v_59; + v_83 = v_59; + v_84 = v_59; + v_85 = v_59; + v_86 = v_59; + v_87 = v_59; + v_88 = v_59; + v_89 = v_59; + v_90 = v_59; + v_91 = v_59; + v_92 = v_59; + v_93 = v_59; + v_94 = v_59; + v_95 = v_59; + v_96 = v_59; + v_97 = v_59; + v_98 = v_59; + v_99 = v_59; + v_100 = v_59; + v_101 = v_59; + v_102 = v_59; + v_103 = v_59; + v_104 = v_59; + v_105 = v_59; + v_106 = v_59; + goto continuation_0; + } + case 2ULL: { + const uint64_t v_60 = 5ULL; + const uint64_t v_61 = 0ULL; + row[layout.selectors + 2] = 1; + v_62 = v_60; + v_63 = v_48; + v_64 = v_49; + v_65 = v_50; + v_66 = v_51; + v_67 = v_52; + v_68 = v_53; + v_69 = v_54; + v_70 = v_55; + v_71 = v_1; + v_72 = v_61; + v_73 = v_61; + v_74 = v_61; + v_75 = v_61; + v_76 = v_61; + v_77 = v_61; + v_78 = v_61; + v_79 = v_61; + v_80 = v_61; + v_81 = v_61; + v_82 = v_61; + v_83 = v_61; + v_84 = v_61; + v_85 = v_61; + v_86 = v_61; + v_87 = v_61; + v_88 = v_61; + v_89 = v_61; + v_90 = v_61; + v_91 = v_61; + v_92 = v_61; + v_93 = v_61; + v_94 = v_61; + v_95 = v_61; + v_96 = v_61; + v_97 = v_61; + v_98 = v_61; + v_99 = v_61; + v_100 = v_61; + v_101 = v_61; + v_102 = v_61; + v_103 = v_61; + v_104 = v_61; + v_105 = v_61; + v_106 = v_61; + goto continuation_0; + } + default: { + return 2; + } + } + continuation_0:; + row[layout.auxiliaries + 54] = v_62; + row[layout.auxiliaries + 55] = v_63; + row[layout.auxiliaries + 56] = v_64; + row[layout.auxiliaries + 57] = v_65; + row[layout.auxiliaries + 58] = v_66; + row[layout.auxiliaries + 59] = v_67; + row[layout.auxiliaries + 60] = v_68; + row[layout.auxiliaries + 61] = v_69; + row[layout.auxiliaries + 62] = v_70; + row[layout.auxiliaries + 63] = v_71; + row[layout.auxiliaries + 64] = v_72; + row[layout.auxiliaries + 65] = v_73; + row[layout.auxiliaries + 66] = v_74; + row[layout.auxiliaries + 67] = v_75; + row[layout.auxiliaries + 68] = v_76; + row[layout.auxiliaries + 69] = v_77; + row[layout.auxiliaries + 70] = v_78; + row[layout.auxiliaries + 71] = v_79; + row[layout.auxiliaries + 72] = v_80; + row[layout.auxiliaries + 73] = v_81; + row[layout.auxiliaries + 74] = v_82; + row[layout.auxiliaries + 75] = v_83; + row[layout.auxiliaries + 76] = v_84; + row[layout.auxiliaries + 77] = v_85; + row[layout.auxiliaries + 78] = v_86; + row[layout.auxiliaries + 79] = v_87; + row[layout.auxiliaries + 80] = v_88; + row[layout.auxiliaries + 81] = v_89; + row[layout.auxiliaries + 82] = v_90; + row[layout.auxiliaries + 83] = v_91; + row[layout.auxiliaries + 84] = v_92; + row[layout.auxiliaries + 85] = v_93; + row[layout.auxiliaries + 86] = v_94; + row[layout.auxiliaries + 87] = v_95; + row[layout.auxiliaries + 88] = v_96; + row[layout.auxiliaries + 89] = v_97; + row[layout.auxiliaries + 90] = v_98; + row[layout.auxiliaries + 91] = v_99; + row[layout.auxiliaries + 92] = v_100; + row[layout.auxiliaries + 93] = v_101; + row[layout.auxiliaries + 94] = v_102; + row[layout.auxiliaries + 95] = v_103; + row[layout.auxiliaries + 96] = v_104; + row[layout.auxiliaries + 97] = v_105; + row[layout.auxiliaries + 98] = v_106; + const uint64_t v_108 = seed.word(57); + row[layout.auxiliaries + 99] = v_108; + const uint64_t v_109 = seed.word(58); + row[layout.auxiliaries + 100] = v_109; + const uint64_t v_110 = seed.word(59); + row[layout.auxiliaries + 101] = v_110; + row[layout.selectors + 3] = 1; + return 0; +} +template __global__ void kernel_ixvm_305(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 200 : 480; + const Seed_ixvm_305 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_305(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_305(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_305<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_305<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_305(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 102) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 200 : encoding == 0 ? 480 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_305); +} + +template struct Seed_ixvm_352 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u8(data + 56); + case 3: return load_u32(data + 44); + case 4: return load_u32(data + 48); + case 5: return load_u32(data + 52); + case 6: return load_u64(data + 8); + case 7: return load_u64(data + 16); + case 8: return load_u64(data + 24); + case 9: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_352(Seed_ixvm_352 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + case 7ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_10 = seed.word(6); + row[layout.auxiliaries + 5] = v_10; + const uint64_t v_11 = seed.word(7); + row[layout.auxiliaries + 6] = v_11; + const uint64_t v_12 = seed.word(8); + row[layout.auxiliaries + 7] = v_12; + row[layout.selectors + 4] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_13 = seed.word(6); + row[layout.auxiliaries + 5] = v_13; + const uint64_t v_14 = seed.word(7); + row[layout.auxiliaries + 6] = v_14; + const uint64_t v_15 = seed.word(8); + row[layout.auxiliaries + 7] = v_15; + const uint64_t v_16 = seed.word(9); + row[layout.auxiliaries + 8] = v_16; + row[layout.selectors + 5] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_17 = seed.word(6); + row[layout.auxiliaries + 5] = v_17; + const uint64_t v_18 = seed.word(7); + row[layout.auxiliaries + 6] = v_18; + const uint64_t v_19 = seed.word(8); + row[layout.auxiliaries + 7] = v_19; + const uint64_t v_20 = seed.word(9); + row[layout.auxiliaries + 8] = v_20; + row[layout.selectors + 6] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_21 = seed.word(6); + row[layout.auxiliaries + 5] = v_21; + row[layout.selectors + 7] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_22 = seed.word(6); + row[layout.auxiliaries + 5] = v_22; + row[layout.selectors + 8] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_352(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 64 : 80; + const Seed_ixvm_352 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_352(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_352(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_352<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_352<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_352(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_352); +} + +template struct Seed_ixvm_357 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 32); + case 5: return load_u32(data + 20); + case 6: return load_u32(data + 24); + case 7: return load_u32(data + 28); + case 8: return load_u8(data + 33); + case 9: return load_u8(data + 34); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_357(Seed_ixvm_357 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_3) { + case 0ULL: { + if (v_4 > 0xffffffffULL || v_1 > 0xffffffffULL) return 3; + const uint32_t op_1 = uint32_t(v_4) - uint32_t(v_1); + const uint64_t v_7 = uint64_t(v_4 < v_1); + row[layout.auxiliaries + 5] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_4 >> 16) & 0xffffULL); + row[layout.auxiliaries + 7] = (uint64_t(op_1) & 0xffffULL); + row[layout.auxiliaries + 8] = ((uint64_t(op_1) >> 16) & 0xffffULL); + row[layout.auxiliaries + 9] = (v_1 & 0xffffULL); + row[layout.auxiliaries + 10] = ((v_1 >> 16) & 0xffffULL); + switch (v_7) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + if (v_4 > 0xffffffffULL || v_2 > 0xffffffffULL) return 3; + const uint32_t op_3 = uint32_t(v_4) - uint32_t(v_2); + const uint64_t v_9 = uint64_t(v_4 < v_2); + row[layout.auxiliaries + 11] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 12] = ((v_4 >> 16) & 0xffffULL); + row[layout.auxiliaries + 13] = (uint64_t(op_3) & 0xffffULL); + row[layout.auxiliaries + 14] = ((uint64_t(op_3) >> 16) & 0xffffULL); + row[layout.auxiliaries + 15] = (v_2 & 0xffffULL); + row[layout.auxiliaries + 16] = ((v_2 >> 16) & 0xffffULL); + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + case 2ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + case 7ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_13 = seed.word(8); + row[layout.auxiliaries + 5] = v_13; + switch (v_13) { + case 1ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_15 = seed.word(9); + row[layout.auxiliaries + 6] = v_15; + row[layout.selectors + 6] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 4ULL: { + const uint64_t v_16 = seed.word(8); + row[layout.auxiliaries + 5] = v_16; + row[layout.selectors + 7] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_17 = seed.word(8); + row[layout.auxiliaries + 5] = v_17; + row[layout.selectors + 8] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_18 = seed.word(8); + row[layout.auxiliaries + 5] = v_18; + row[layout.selectors + 9] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_19 = seed.word(8); + row[layout.auxiliaries + 5] = v_19; + row[layout.selectors + 10] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_357(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 80; + const Seed_ixvm_357 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_357(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_357(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_357<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_357<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_357(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 11 || width < auxiliaries || width - auxiliaries < 17) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_357); +} + +__device__ __constant__ uint64_t inverse_365_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_365 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u32(data + 24); + case 4: return load_u8(data + 28); + case 5: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_365(Seed_ixvm_365 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_2; + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 2] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_5 <= 1ULL ? inverse_365_0[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(5); + row[layout.auxiliaries + 4] = v_7; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_365(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 48; + const Seed_ixvm_365 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_365(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_365(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_365<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_365<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_365(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_365); +} + +__device__ __constant__ uint64_t inverse_366_0[] = {0ULL}; +template struct Seed_ixvm_366 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u8(data + 48); + case 4: return load_u32(data + 32); + case 5: return load_u32(data + 36); + case 6: return load_u32(data + 40); + case 7: return load_u64(data + 8); + case 8: return load_u32(data + 44); + case 9: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_366(Seed_ixvm_366 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_2) { + case 0ULL: { + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 5] = v_6; + switch (v_6) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + case 2ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + case 7ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_12 = seed.word(7); + row[layout.auxiliaries + 5] = v_12; + switch (v_12) { + case 0ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_12 <= 0ULL ? inverse_366_0[v_12] : inverse(goldilocks_sub(v_12, 0ULL))); + const uint64_t v_14 = seed.word(8); + row[layout.auxiliaries + 7] = v_14; + const uint64_t v_15 = seed.word(9); + row[layout.auxiliaries + 8] = v_15; + row[layout.selectors + 6] = 1; + return 0; + } + } + } + case 4ULL: { + const uint64_t v_16 = seed.word(7); + row[layout.auxiliaries + 5] = v_16; + row[layout.selectors + 7] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_17 = seed.word(7); + row[layout.auxiliaries + 5] = v_17; + row[layout.selectors + 8] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_18 = seed.word(7); + row[layout.auxiliaries + 5] = v_18; + row[layout.selectors + 9] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_19 = seed.word(7); + row[layout.auxiliaries + 5] = v_19; + row[layout.selectors + 10] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_366(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 80; + const Seed_ixvm_366 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_366(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_366(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_366<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_366<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_366(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 11 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_366); +} + +__device__ __constant__ uint64_t inverse_373_0[] = {0ULL}; +template struct Seed_ixvm_373 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u32(data + 28); + case 4: return load_u32(data + 32); + case 5: return load_u8(data + 36); + case 6: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_373(Seed_ixvm_373 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_373_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 2] = v_3; + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 3] = v_4; + switch (v_4) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 4] = v_5; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_373(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 56; + const Seed_ixvm_373 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_373(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_373(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_373<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_373<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_373(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_373); +} + +template struct Seed_ixvm_374 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u64(data + 8); + case 3: return load_u32(data + 44); + case 4: return load_u8(data + 64); + case 5: return load_u32(data + 48); + case 6: return load_u32(data + 52); + case 7: return load_u32(data + 56); + case 8: return load_u64(data + 16); + case 9: return load_u64(data + 24); + case 10: return load_u64(data + 32); + case 11: return load_u32(data + 60); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_374(Seed_ixvm_374 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_3) { + case 0ULL: { + if (v_4 > 0xffffffffULL || v_2 > 0xffffffffULL) return 3; + const uint32_t op_1 = uint32_t(v_4) - uint32_t(v_2); + const uint64_t v_7 = uint64_t(v_4 < v_2); + row[layout.auxiliaries + 5] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_4 >> 16) & 0xffffULL); + row[layout.auxiliaries + 7] = (uint64_t(op_1) & 0xffffULL); + row[layout.auxiliaries + 8] = ((uint64_t(op_1) >> 16) & 0xffffULL); + row[layout.auxiliaries + 9] = (v_2 & 0xffffULL); + row[layout.auxiliaries + 10] = ((v_2 >> 16) & 0xffffULL); + switch (v_7) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 11] = v_10; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 1ULL: { + const uint64_t v_13 = seed.word(8); + row[layout.auxiliaries + 5] = v_13; + row[layout.selectors + 2] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_16 = seed.word(8); + row[layout.auxiliaries + 5] = v_16; + row[layout.selectors + 3] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_18 = seed.word(8); + row[layout.auxiliaries + 5] = v_18; + const uint64_t v_19 = seed.word(9); + row[layout.auxiliaries + 6] = v_19; + const uint64_t v_21 = seed.word(10); + row[layout.auxiliaries + 7] = v_21; + row[layout.selectors + 4] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_23 = seed.word(8); + row[layout.auxiliaries + 5] = v_23; + const uint64_t v_26 = seed.word(9); + row[layout.auxiliaries + 6] = v_26; + const uint64_t v_28 = seed.word(10); + row[layout.auxiliaries + 7] = v_28; + row[layout.selectors + 5] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_30 = seed.word(8); + row[layout.auxiliaries + 5] = v_30; + const uint64_t v_33 = seed.word(9); + row[layout.auxiliaries + 6] = v_33; + const uint64_t v_35 = seed.word(10); + row[layout.auxiliaries + 7] = v_35; + row[layout.selectors + 6] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_37 = seed.word(8); + row[layout.auxiliaries + 5] = v_37; + const uint64_t v_38 = seed.word(9); + row[layout.auxiliaries + 6] = v_38; + const uint64_t v_41 = seed.word(10); + row[layout.auxiliaries + 7] = v_41; + const uint64_t v_42 = seed.word(11); + row[layout.auxiliaries + 8] = v_42; + row[layout.selectors + 7] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_45 = seed.word(8); + row[layout.auxiliaries + 5] = v_45; + row[layout.selectors + 8] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_47 = seed.word(8); + row[layout.auxiliaries + 5] = v_47; + const uint64_t v_48 = seed.word(9); + row[layout.auxiliaries + 6] = v_48; + row[layout.selectors + 9] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_374(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 72 : 96; + const Seed_ixvm_374 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_374(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_374(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_374<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_374<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_374(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 10 || width < auxiliaries || width - auxiliaries < 12) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 72 : encoding == 0 ? 96 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_374); +} + +__device__ __constant__ uint64_t inverse_380_0[] = {0ULL}; +template struct Seed_ixvm_380 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u32(data + 24); + case 4: return load_u8(data + 28); + case 5: return load_u64(data + 8); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_380(Seed_ixvm_380 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + switch (v_3) { + case 1ULL: { + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_5; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = goldilocks_sub(v_0, v_2); + switch (v_6) { + case 0ULL: { + const uint64_t v_8 = seed.word(5); + row[layout.auxiliaries + 2] = v_8; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_6 <= 0ULL ? inverse_380_0[v_6] : inverse(goldilocks_sub(v_6, 0ULL))); + const uint64_t v_12 = seed.word(5); + row[layout.auxiliaries + 3] = v_12; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_380(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 48; + const Seed_ixvm_380 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_380(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_380(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_380<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_380<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_380(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 48 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_380); +} + +__device__ __constant__ uint64_t inverse_382_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_382_1[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_382 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u32(data + 32); + case 4: return load_u64(data + 8); + case 5: return load_u32(data + 36); + case 6: return load_u8(data + 40); + case 7: return load_u8(data + 41); + case 8: return load_u64(data + 16); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_382(Seed_ixvm_382 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + switch (v_3) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_3 <= 0ULL ? inverse_382_0[v_3] : inverse(goldilocks_sub(v_3, 0ULL))); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 3] = v_4; + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 4] = v_5; + switch (v_5) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 5] = v_7; + switch (v_7) { + case 1ULL: { + const uint64_t v_8 = seed.word(8); + row[layout.auxiliaries + 6] = v_8; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_7 <= 1ULL ? inverse_382_1[v_7] : inverse(goldilocks_sub(v_7, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 7] = v_10; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_382(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 72; + const Seed_ixvm_382 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_382(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_382(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_382<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_382<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_382(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 72 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_382); +} + +template struct Seed_ixvm_383 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u32(data + 32); + case 3: return load_u64(data + 16); + case 4: return load_u32(data + 36); + case 5: return load_u8(data + 44); + case 6: return load_u32(data + 40); + case 7: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_383(Seed_ixvm_383 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_5; + switch (v_5) { + case 1ULL: { + const uint64_t v_6 = seed.word(6); + row[layout.auxiliaries + 3] = v_6; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 4] = v_8; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_11 = seed.word(6); + row[layout.auxiliaries + 3] = v_11; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_383(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_383 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_383(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_383(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_383<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_383<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_383(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_383); +} + +template struct Seed_ixvm_384 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u32(data + 32); + case 4: return load_u8(data + 52); + case 5: return load_u32(data + 36); + case 6: return load_u32(data + 40); + case 7: return load_u32(data + 44); + case 8: return load_u64(data + 8); + case 9: return load_u64(data + 16); + case 10: return load_u32(data + 48); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_384(Seed_ixvm_384 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + switch (v_3) { + case 0ULL: { + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 5] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 5] = v_10; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_13 = seed.word(8); + row[layout.auxiliaries + 5] = v_13; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_15 = seed.word(8); + row[layout.auxiliaries + 5] = v_15; + const uint64_t v_16 = seed.word(9); + row[layout.auxiliaries + 6] = v_16; + const uint64_t v_18 = seed.word(10); + row[layout.auxiliaries + 7] = v_18; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_20 = seed.word(8); + row[layout.auxiliaries + 5] = v_20; + const uint64_t v_23 = seed.word(9); + row[layout.auxiliaries + 6] = v_23; + const uint64_t v_25 = seed.word(10); + row[layout.auxiliaries + 7] = v_25; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_27 = seed.word(8); + row[layout.auxiliaries + 5] = v_27; + const uint64_t v_30 = seed.word(9); + row[layout.auxiliaries + 6] = v_30; + const uint64_t v_32 = seed.word(10); + row[layout.auxiliaries + 7] = v_32; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_33 = seed.word(8); + row[layout.auxiliaries + 5] = v_33; + row[layout.selectors + 6] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_36 = seed.word(8); + row[layout.auxiliaries + 5] = v_36; + row[layout.selectors + 7] = 1; + return 0; + } + case 8ULL: { + const uint64_t v_38 = seed.word(8); + row[layout.auxiliaries + 5] = v_38; + const uint64_t v_39 = seed.word(9); + row[layout.auxiliaries + 6] = v_39; + row[layout.selectors + 8] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_384(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 88; + const Seed_ixvm_384 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_384(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_384(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_384<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_384<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_384(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_384); +} + +__device__ __constant__ uint64_t inverse_396_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_396_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_396_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_396_3[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_396_4[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_396_5[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_396_6[] = {9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_396_7[] = {0ULL}; +template struct Seed_ixvm_396 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 128); + case 2: return load_u64(data + 8); + case 3: return load_u32(data + 132); + case 4: return load_u32(data + 136); + case 5: return load_u32(data + 140); + case 6: return load_u8(data + 236); + case 7: return load_u32(data + 144); + case 8: return load_u32(data + 148); + case 9: return load_u64(data + 16); + case 10: return load_u64(data + 24); + case 11: return load_u32(data + 152); + case 12: return load_u8(data + 237); + case 13: return load_u32(data + 156); + case 14: return load_u64(data + 32); + case 15: return load_u32(data + 160); + case 16: return load_u32(data + 164); + case 17: return load_u32(data + 168); + case 18: return load_u64(data + 40); + case 19: return load_u8(data + 238); + case 20: return load_u64(data + 48); + case 21: return load_u64(data + 56); + case 22: return load_u64(data + 64); + case 23: return load_u32(data + 172); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u64(data + 88); + case 27: return load_u32(data + 176); + case 28: return load_u32(data + 180); + case 29: return load_u8(data + 239); + case 30: return load_u64(data + 96); + case 31: return load_u64(data + 104); + case 32: return load_u64(data + 112); + case 33: return load_u32(data + 184); + case 34: return load_u32(data + 188); + case 35: return load_u32(data + 192); + case 36: return load_u32(data + 196); + case 37: return load_u32(data + 200); + case 38: return load_u32(data + 204); + case 39: return load_u32(data + 208); + case 40: return load_u32(data + 212); + case 41: return load_u32(data + 216); + case 42: return load_u32(data + 220); + case 43: return load_u32(data + 224); + case 44: return load_u32(data + 228); + case 45: return load_u32(data + 232); + case 46: return load_u64(data + 120); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_396(Seed_ixvm_396 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_4; + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 2] = v_5; + switch (v_5) { + case 0ULL: { + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 3] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_5 <= 0ULL ? inverse_396_0[v_5] : inverse(goldilocks_sub(v_5, 0ULL))); + switch (v_1) { + case 0ULL: { + const uint64_t v_8 = seed.word(7); + const uint64_t v_9 = seed.word(8); + const uint64_t v_10 = seed.word(9); + const uint64_t v_11 = seed.word(10); + row[layout.auxiliaries + 4] = v_8; + row[layout.auxiliaries + 5] = v_9; + row[layout.auxiliaries + 6] = v_10; + row[layout.auxiliaries + 7] = v_11; + switch (v_8) { + case 2ULL: { + const uint64_t v_12 = seed.word(11); + row[layout.auxiliaries + 8] = v_12; + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 9] = v_13; + switch (v_13) { + case 0ULL: { + const uint64_t v_15 = seed.word(13); + row[layout.auxiliaries + 10] = v_15; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 10] = (v_13 <= 0ULL ? inverse_396_1[v_13] : inverse(goldilocks_sub(v_13, 0ULL))); + const uint64_t v_16 = seed.word(13); + row[layout.auxiliaries + 11] = v_16; + const uint64_t v_17 = 5ULL; + if (v_16 > 0xffffffffULL || v_17 > 0xffffffffULL) return 3; + const uint32_t op_11 = uint32_t(v_16) - uint32_t(v_17); + const uint64_t v_18 = uint64_t(v_16 < v_17); + row[layout.auxiliaries + 12] = (v_16 & 0xffffULL); + row[layout.auxiliaries + 13] = ((v_16 >> 16) & 0xffffULL); + row[layout.auxiliaries + 14] = (uint64_t(op_11) & 0xffffULL); + row[layout.auxiliaries + 15] = ((uint64_t(op_11) >> 16) & 0xffffULL); + row[layout.auxiliaries + 16] = (v_17 & 0xffffULL); + row[layout.auxiliaries + 17] = ((v_17 >> 16) & 0xffffULL); + switch (v_18) { + case 1ULL: { + const uint64_t v_20 = seed.word(14); + row[layout.auxiliaries + 18] = v_20; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 18] = (v_18 <= 1ULL ? inverse_396_2[v_18] : inverse(goldilocks_sub(v_18, 1ULL))); + const uint64_t v_22 = seed.word(14); + row[layout.auxiliaries + 19] = v_22; + const uint64_t v_24 = seed.word(15); + row[layout.auxiliaries + 20] = v_24; + const uint64_t v_26 = seed.word(16); + row[layout.auxiliaries + 21] = v_26; + const uint64_t v_28 = seed.word(17); + row[layout.auxiliaries + 22] = v_28; + const uint64_t v_30 = seed.word(18); + row[layout.auxiliaries + 23] = v_30; + const uint64_t v_31 = seed.word(19); + const uint64_t v_32 = seed.word(20); + const uint64_t v_33 = seed.word(21); + const uint64_t v_34 = seed.word(22); + row[layout.auxiliaries + 24] = v_31; + row[layout.auxiliaries + 25] = v_32; + row[layout.auxiliaries + 26] = v_33; + row[layout.auxiliaries + 27] = v_34; + switch (v_31) { + case 4ULL: { + const uint64_t v_35 = seed.word(23); + const uint64_t v_36 = seed.word(24); + const uint64_t v_37 = seed.word(25); + const uint64_t v_38 = seed.word(26); + row[layout.auxiliaries + 28] = v_35; + row[layout.auxiliaries + 29] = v_36; + row[layout.auxiliaries + 30] = v_37; + row[layout.auxiliaries + 31] = v_38; + switch (v_35) { + case 4ULL: { + const uint64_t v_40 = seed.word(27); + row[layout.auxiliaries + 32] = v_40; + const uint64_t v_43 = seed.word(28); + row[layout.auxiliaries + 33] = v_43; + const uint64_t v_44 = seed.word(29); + const uint64_t v_45 = seed.word(30); + const uint64_t v_46 = seed.word(31); + const uint64_t v_47 = seed.word(32); + row[layout.auxiliaries + 34] = v_44; + row[layout.auxiliaries + 35] = v_45; + row[layout.auxiliaries + 36] = v_46; + row[layout.auxiliaries + 37] = v_47; + switch (v_44) { + case 4ULL: { + const uint64_t v_49 = seed.word(33); + row[layout.auxiliaries + 38] = v_49; + const uint64_t v_52 = seed.word(34); + row[layout.auxiliaries + 39] = v_52; + const uint64_t v_54 = seed.word(35); + row[layout.auxiliaries + 40] = v_54; + const uint64_t v_56 = seed.word(36); + row[layout.auxiliaries + 41] = v_56; + const uint64_t v_57 = seed.word(37); + row[layout.auxiliaries + 42] = v_57; + const uint64_t v_58 = seed.word(38); + row[layout.auxiliaries + 43] = v_58; + const uint64_t v_59 = seed.word(39); + row[layout.auxiliaries + 44] = v_59; + const uint64_t v_61 = seed.word(40); + row[layout.auxiliaries + 45] = v_61; + const uint64_t v_62 = seed.word(41); + row[layout.auxiliaries + 46] = v_62; + const uint64_t v_63 = seed.word(42); + row[layout.auxiliaries + 47] = v_63; + const uint64_t v_64 = seed.word(43); + row[layout.auxiliaries + 48] = v_64; + const uint64_t v_65 = seed.word(44); + row[layout.auxiliaries + 49] = v_65; + const uint64_t v_67 = seed.word(45); + row[layout.auxiliaries + 50] = v_67; + const uint64_t v_68 = seed.word(46); + row[layout.auxiliaries + 51] = v_68; + row[layout.selectors + 3] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 38] = (v_44 <= 4ULL ? inverse_396_3[v_44] : inverse(goldilocks_sub(v_44, 4ULL))); + const uint64_t v_70 = seed.word(33); + row[layout.auxiliaries + 39] = v_70; + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 32] = (v_35 <= 4ULL ? inverse_396_4[v_35] : inverse(goldilocks_sub(v_35, 4ULL))); + const uint64_t v_72 = seed.word(27); + row[layout.auxiliaries + 33] = v_72; + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 28] = (v_31 <= 4ULL ? inverse_396_5[v_31] : inverse(goldilocks_sub(v_31, 4ULL))); + const uint64_t v_74 = seed.word(23); + row[layout.auxiliaries + 29] = v_74; + row[layout.selectors + 6] = 1; + return 0; + } + } + } + } + } + } + } + default: { + row[layout.auxiliaries + 8] = (v_8 <= 2ULL ? inverse_396_6[v_8] : inverse(goldilocks_sub(v_8, 2ULL))); + const uint64_t v_76 = seed.word(11); + row[layout.auxiliaries + 9] = v_76; + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 4] = (v_1 <= 0ULL ? inverse_396_7[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_78 = seed.word(7); + row[layout.auxiliaries + 5] = v_78; + row[layout.selectors + 8] = 1; + return 0; + } + } + } + } +} +template __global__ void kernel_ixvm_396(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 240 : 376; + const Seed_ixvm_396 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_396(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_396(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_396<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_396<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_396(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 52) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 240 : encoding == 0 ? 376 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_396); +} + +__device__ __constant__ uint64_t inverse_401_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_3[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_4[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_5[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_6[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_7[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_8[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_9[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_10[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_11[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_12[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_13[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_14[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_15[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_16[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_17[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_18[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_19[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_20[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_21[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_401_22[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_401 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 78); + case 4: return load_u32(data + 16); + case 5: return load_u8(data + 79); + case 6: return load_u32(data + 20); + case 7: return load_u8(data + 80); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 81); + case 10: return load_u32(data + 28); + case 11: return load_u8(data + 82); + case 12: return load_u32(data + 32); + case 13: return load_u8(data + 83); + case 14: return load_u32(data + 36); + case 15: return load_u8(data + 84); + case 16: return load_u32(data + 40); + case 17: return load_u8(data + 85); + case 18: return load_u32(data + 44); + case 19: return load_u8(data + 86); + case 20: return load_u32(data + 48); + case 21: return load_u8(data + 87); + case 22: return load_u32(data + 52); + case 23: return load_u8(data + 88); + case 24: return load_u32(data + 56); + case 25: return load_u8(data + 89); + case 26: return load_u32(data + 60); + case 27: return load_u8(data + 90); + case 28: return load_u32(data + 64); + case 29: return load_u8(data + 91); + case 30: return load_u32(data + 68); + case 31: return load_u8(data + 92); + case 32: return load_u32(data + 72); + case 33: return load_u8(data + 93); + case 34: return load_u8(data + 94); + case 35: return load_u8(data + 95); + case 36: return load_u8(data + 96); + case 37: return load_u8(data + 97); + case 38: return load_u16(data + 76); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_401(Seed_ixvm_401 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 2] = v_2; + uint64_t v_50; + switch (v_2) { + case 1ULL: { + const uint64_t v_3 = 1ULL; + row[layout.selectors + 0] = 1; + v_50 = v_3; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 3] = (v_2 <= 1ULL ? inverse_401_1[v_2] : inverse(goldilocks_sub(v_2, 1ULL))); + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 4] = v_4; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 5] = v_5; + switch (v_5) { + case 1ULL: { + const uint64_t v_6 = 1ULL; + row[layout.selectors + 1] = 1; + v_50 = v_6; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 6] = (v_5 <= 1ULL ? inverse_401_2[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 7] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 8] = v_8; + switch (v_8) { + case 1ULL: { + const uint64_t v_9 = 1ULL; + row[layout.selectors + 2] = 1; + v_50 = v_9; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_401_3[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 11] = v_11; + switch (v_11) { + case 1ULL: { + const uint64_t v_12 = 1ULL; + row[layout.selectors + 3] = 1; + v_50 = v_12; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 12] = (v_11 <= 1ULL ? inverse_401_4[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(10); + row[layout.auxiliaries + 13] = v_13; + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 14] = v_14; + switch (v_14) { + case 1ULL: { + const uint64_t v_15 = 1ULL; + row[layout.selectors + 4] = 1; + v_50 = v_15; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 15] = (v_14 <= 1ULL ? inverse_401_5[v_14] : inverse(goldilocks_sub(v_14, 1ULL))); + const uint64_t v_16 = seed.word(12); + row[layout.auxiliaries + 16] = v_16; + const uint64_t v_17 = seed.word(13); + row[layout.auxiliaries + 17] = v_17; + switch (v_17) { + case 1ULL: { + const uint64_t v_18 = 1ULL; + row[layout.selectors + 5] = 1; + v_50 = v_18; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 18] = (v_17 <= 1ULL ? inverse_401_6[v_17] : inverse(goldilocks_sub(v_17, 1ULL))); + const uint64_t v_19 = seed.word(14); + row[layout.auxiliaries + 19] = v_19; + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 20] = v_20; + switch (v_20) { + case 1ULL: { + const uint64_t v_21 = 1ULL; + row[layout.selectors + 6] = 1; + v_50 = v_21; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 21] = (v_20 <= 1ULL ? inverse_401_7[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); + const uint64_t v_22 = seed.word(16); + row[layout.auxiliaries + 22] = v_22; + const uint64_t v_23 = seed.word(17); + row[layout.auxiliaries + 23] = v_23; + switch (v_23) { + case 1ULL: { + const uint64_t v_24 = 1ULL; + row[layout.selectors + 7] = 1; + v_50 = v_24; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 24] = (v_23 <= 1ULL ? inverse_401_8[v_23] : inverse(goldilocks_sub(v_23, 1ULL))); + const uint64_t v_25 = seed.word(18); + row[layout.auxiliaries + 25] = v_25; + const uint64_t v_26 = seed.word(19); + row[layout.auxiliaries + 26] = v_26; + switch (v_26) { + case 1ULL: { + const uint64_t v_27 = 1ULL; + row[layout.selectors + 8] = 1; + v_50 = v_27; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 27] = (v_26 <= 1ULL ? inverse_401_9[v_26] : inverse(goldilocks_sub(v_26, 1ULL))); + const uint64_t v_28 = seed.word(20); + row[layout.auxiliaries + 28] = v_28; + const uint64_t v_29 = seed.word(21); + row[layout.auxiliaries + 29] = v_29; + switch (v_29) { + case 1ULL: { + const uint64_t v_30 = 1ULL; + row[layout.selectors + 9] = 1; + v_50 = v_30; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 30] = (v_29 <= 1ULL ? inverse_401_10[v_29] : inverse(goldilocks_sub(v_29, 1ULL))); + const uint64_t v_31 = seed.word(22); + row[layout.auxiliaries + 31] = v_31; + const uint64_t v_32 = seed.word(23); + row[layout.auxiliaries + 32] = v_32; + switch (v_32) { + case 1ULL: { + const uint64_t v_33 = 1ULL; + row[layout.selectors + 10] = 1; + v_50 = v_33; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 33] = (v_32 <= 1ULL ? inverse_401_11[v_32] : inverse(goldilocks_sub(v_32, 1ULL))); + const uint64_t v_34 = seed.word(24); + row[layout.auxiliaries + 34] = v_34; + const uint64_t v_35 = seed.word(25); + row[layout.auxiliaries + 35] = v_35; + switch (v_35) { + case 1ULL: { + const uint64_t v_36 = 1ULL; + row[layout.selectors + 11] = 1; + v_50 = v_36; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 36] = (v_35 <= 1ULL ? inverse_401_12[v_35] : inverse(goldilocks_sub(v_35, 1ULL))); + const uint64_t v_37 = seed.word(26); + row[layout.auxiliaries + 37] = v_37; + const uint64_t v_38 = seed.word(27); + row[layout.auxiliaries + 38] = v_38; + switch (v_38) { + case 1ULL: { + const uint64_t v_39 = 1ULL; + row[layout.selectors + 12] = 1; + v_50 = v_39; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 39] = (v_38 <= 1ULL ? inverse_401_13[v_38] : inverse(goldilocks_sub(v_38, 1ULL))); + const uint64_t v_40 = seed.word(28); + row[layout.auxiliaries + 40] = v_40; + const uint64_t v_41 = seed.word(29); + row[layout.auxiliaries + 41] = v_41; + switch (v_41) { + case 1ULL: { + const uint64_t v_42 = 1ULL; + row[layout.selectors + 13] = 1; + v_50 = v_42; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 42] = (v_41 <= 1ULL ? inverse_401_14[v_41] : inverse(goldilocks_sub(v_41, 1ULL))); + const uint64_t v_43 = seed.word(30); + row[layout.auxiliaries + 43] = v_43; + const uint64_t v_44 = seed.word(31); + row[layout.auxiliaries + 44] = v_44; + switch (v_44) { + case 1ULL: { + const uint64_t v_45 = 1ULL; + row[layout.selectors + 14] = 1; + v_50 = v_45; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 45] = (v_44 <= 1ULL ? inverse_401_15[v_44] : inverse(goldilocks_sub(v_44, 1ULL))); + const uint64_t v_46 = seed.word(32); + row[layout.auxiliaries + 46] = v_46; + const uint64_t v_47 = seed.word(33); + row[layout.auxiliaries + 47] = v_47; + switch (v_47) { + case 1ULL: { + const uint64_t v_48 = 1ULL; + row[layout.selectors + 15] = 1; + v_50 = v_48; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 48] = (v_47 <= 1ULL ? inverse_401_16[v_47] : inverse(goldilocks_sub(v_47, 1ULL))); + const uint64_t v_49 = 0ULL; + row[layout.selectors + 16] = 1; + v_50 = v_49; + goto continuation_0; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + continuation_0:; + row[layout.auxiliaries + 49] = v_50; + switch (v_50) { + case 1ULL: { + row[layout.selectors + 17] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 50] = (v_50 <= 1ULL ? inverse_401_17[v_50] : inverse(goldilocks_sub(v_50, 1ULL))); + const uint64_t v_52 = seed.word(34); + row[layout.auxiliaries + 51] = v_52; + switch (v_52) { + case 1ULL: { + row[layout.selectors + 18] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 52] = (v_52 <= 1ULL ? inverse_401_18[v_52] : inverse(goldilocks_sub(v_52, 1ULL))); + const uint64_t v_54 = seed.word(35); + row[layout.auxiliaries + 53] = v_54; + switch (v_54) { + case 1ULL: { + row[layout.selectors + 19] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 54] = (v_54 <= 1ULL ? inverse_401_19[v_54] : inverse(goldilocks_sub(v_54, 1ULL))); + const uint64_t v_56 = seed.word(36); + row[layout.auxiliaries + 55] = v_56; + switch (v_56) { + case 1ULL: { + row[layout.selectors + 20] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 56] = (v_56 <= 1ULL ? inverse_401_20[v_56] : inverse(goldilocks_sub(v_56, 1ULL))); + const uint64_t v_58 = seed.word(37); + row[layout.auxiliaries + 57] = v_58; + switch (v_58) { + case 1ULL: { + row[layout.selectors + 21] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 58] = (v_58 <= 1ULL ? inverse_401_21[v_58] : inverse(goldilocks_sub(v_58, 1ULL))); + const uint64_t v_60 = seed.word(38); + row[layout.auxiliaries + 59] = v_60; + switch (v_60) { + case 1ULL: { + row[layout.selectors + 22] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 60] = (v_60 <= 1ULL ? inverse_401_22[v_60] : inverse(goldilocks_sub(v_60, 1ULL))); + row[layout.selectors + 23] = 1; + return 0; + } + } + } + } + } + } + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_401(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 104 : 312; + const Seed_ixvm_401 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_401(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_401(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_401<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_401<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_401(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 24 || width < auxiliaries || width - auxiliaries < 61) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 104 : encoding == 0 ? 312 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_401); +} + +__device__ __constant__ uint64_t inverse_451_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_451 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 20); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_451(Seed_ixvm_451 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + if (v_0 > 0xffffffffULL || v_1 > 0xffffffffULL) return 3; + const uint32_t op_0 = uint32_t(v_0) - uint32_t(v_1); + const uint64_t v_3 = uint64_t(v_0 < v_1); + row[layout.auxiliaries + 1] = (v_0 & 0xffffULL); + row[layout.auxiliaries + 2] = ((v_0 >> 16) & 0xffffULL); + row[layout.auxiliaries + 3] = (uint64_t(op_0) & 0xffffULL); + row[layout.auxiliaries + 4] = ((uint64_t(op_0) >> 16) & 0xffffULL); + row[layout.auxiliaries + 5] = (v_1 & 0xffffULL); + row[layout.auxiliaries + 6] = ((v_1 >> 16) & 0xffffULL); + switch (v_3) { + case 1ULL: { + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 7] = v_4; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 7] = (v_3 <= 1ULL ? inverse_451_0[v_3] : inverse(goldilocks_sub(v_3, 1ULL))); + const uint64_t v_5 = seed.word(4); + row[layout.auxiliaries + 8] = v_5; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_451(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 24 : 40; + const Seed_ixvm_451 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_451(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_451(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_451<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_451<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_451(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 40 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_451); +} + +__device__ __constant__ uint64_t inverse_457_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_457_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_457_2[] = {0ULL}; +template struct Seed_ixvm_457 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u32(data + 16); + case 4: return load_u8(data + 36); + case 5: return load_u8(data + 37); + case 6: return load_u8(data + 38); + case 7: return load_u32(data + 20); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 39); + case 10: return load_u32(data + 28); + case 11: return load_u32(data + 32); + case 12: return load_u8(data + 40); + case 13: return load_u8(data + 41); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_457(Seed_ixvm_457 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 2] = v_4; + const uint64_t v_5 = goldilocks_mul(v_3, v_4); + row[layout.auxiliaries + 3] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 4] = (v_5 <= 1ULL ? inverse_457_0[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + const uint64_t v_8 = seed.word(7); + const uint64_t v_9 = seed.word(8); + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + const uint64_t v_10 = seed.word(9); + const uint64_t v_11 = seed.word(10); + const uint64_t v_12 = seed.word(11); + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + const uint64_t v_13 = goldilocks_mul(v_7, v_10); + row[layout.auxiliaries + 11] = v_13; + switch (v_13) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_13 <= 0ULL ? inverse_457_1[v_13] : inverse(goldilocks_sub(v_13, 0ULL))); + const uint64_t v_15 = seed.word(12); + row[layout.auxiliaries + 13] = v_15; + switch (v_15) { + case 0ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 14] = (v_15 <= 0ULL ? inverse_457_2[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); + const uint64_t v_18 = seed.word(13); + row[layout.auxiliaries + 15] = v_18; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_457(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 112; + const Seed_ixvm_457 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_457(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_457(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_457<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_457<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_457(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 112 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_457); +} + +__device__ __constant__ uint64_t inverse_487_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_487 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u32(data + 36); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 40); + case 5: return load_u8(data + 52); + case 6: return load_u32(data + 44); + case 7: return load_u32(data + 48); + case 8: return load_u8(data + 53); + case 9: return load_u64(data + 16); + case 10: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_487(Seed_ixvm_487 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_4; + row[layout.auxiliaries + 2] = v_5; + switch (v_4) { + case 1ULL: { + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 3] = v_6; + const uint64_t v_9 = seed.word(8); + const uint64_t v_10 = seed.word(9); + const uint64_t v_11 = seed.word(10); + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_4 <= 1ULL ? inverse_487_0[v_4] : inverse(goldilocks_sub(v_4, 1ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_487(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 88; + const Seed_ixvm_487 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_487(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_487(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_487<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_487<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_487(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_487); +} + +__device__ __constant__ uint64_t inverse_512_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_512_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_512_3[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_512_5[] = {0ULL}; +template struct Seed_ixvm_512 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 64); + case 2: return load_u32(data + 68); + case 3: return load_u32(data + 72); + case 4: return load_u32(data + 76); + case 5: return load_u8(data + 116); + case 6: return load_u32(data + 80); + case 7: return load_u32(data + 84); + case 8: return load_u64(data + 8); + case 9: return load_u64(data + 16); + case 10: return load_u32(data + 88); + case 11: return load_u64(data + 24); + case 12: return load_u64(data + 32); + case 13: return load_u32(data + 92); + case 14: return load_u32(data + 96); + case 15: return load_u64(data + 40); + case 16: return load_u32(data + 100); + case 17: return load_u32(data + 104); + case 18: return load_u64(data + 48); + case 19: return load_u32(data + 108); + case 20: return load_u32(data + 112); + case 21: return load_u64(data + 56); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_512(Seed_ixvm_512 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 1] = v_4; + row[layout.auxiliaries + 2] = v_5; + row[layout.auxiliaries + 3] = v_6; + switch (v_4) { + case 1ULL: { + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 4] = v_7; + switch (v_7) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 5] = (v_7 <= 0ULL ? inverse_512_0[v_7] : inverse(goldilocks_sub(v_7, 0ULL))); + const uint64_t v_9 = seed.word(9); + row[layout.auxiliaries + 6] = v_9; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + case 0ULL: { + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + row[layout.auxiliaries + 4] = v_10; + row[layout.auxiliaries + 5] = v_11; + row[layout.auxiliaries + 6] = v_12; + row[layout.auxiliaries + 7] = v_13; + switch (v_10) { + case 5ULL: { + const uint64_t v_14 = seed.word(12); + row[layout.auxiliaries + 8] = v_14; + uint64_t v_17; + switch (v_14) { + case 0ULL: { + row[layout.selectors + 2] = 1; + v_17 = v_11; + goto continuation_1; + } + default: { + row[layout.auxiliaries + 9] = (v_14 <= 0ULL ? inverse_512_2[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); + const uint64_t v_16 = seed.word(13); + row[layout.auxiliaries + 10] = v_16; + row[layout.selectors + 3] = 1; + v_17 = v_16; + goto continuation_1; + } + } + continuation_1:; + row[layout.auxiliaries + 11] = v_17; + const uint64_t v_19 = seed.word(14); + row[layout.auxiliaries + 12] = v_19; + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 13] = v_20; + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 8] = (v_10 <= 5ULL ? inverse_512_3[v_10] : inverse(goldilocks_sub(v_10, 5ULL))); + const uint64_t v_21 = seed.word(12); + row[layout.auxiliaries + 9] = v_21; + uint64_t v_24; + switch (v_21) { + case 0ULL: { + row[layout.selectors + 5] = 1; + v_24 = v_0; + goto continuation_4; + } + default: { + row[layout.auxiliaries + 10] = (v_21 <= 0ULL ? inverse_512_5[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); + const uint64_t v_23 = seed.word(13); + row[layout.auxiliaries + 11] = v_23; + row[layout.selectors + 6] = 1; + v_24 = v_23; + goto continuation_4; + } + } + continuation_4:; + row[layout.auxiliaries + 12] = v_24; + const uint64_t v_25 = seed.word(14); + row[layout.auxiliaries + 13] = v_25; + const uint64_t v_26 = seed.word(15); + const uint64_t v_27 = seed.word(16); + const uint64_t v_28 = seed.word(17); + const uint64_t v_29 = seed.word(18); + row[layout.auxiliaries + 14] = v_26; + row[layout.auxiliaries + 15] = v_27; + row[layout.auxiliaries + 16] = v_28; + row[layout.auxiliaries + 17] = v_29; + switch (v_26) { + case 5ULL: { + const uint64_t v_32 = seed.word(19); + row[layout.auxiliaries + 18] = v_32; + const uint64_t v_33 = seed.word(20); + row[layout.auxiliaries + 19] = v_33; + const uint64_t v_34 = seed.word(21); + row[layout.auxiliaries + 20] = v_34; + row[layout.selectors + 7] = 1; + return 0; + } + default: { + return 2; + } + } + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_512(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 120 : 176; + const Seed_ixvm_512 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_512(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_512(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_512<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_512<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_512(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 21) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 176 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_512); +} + +__device__ __constant__ uint64_t inverse_536_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_536_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_536_2[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_536_3[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_536_4[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_536_5[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_536 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 36); + case 4: return load_u32(data + 16); + case 5: return load_u8(data + 37); + case 6: return load_u32(data + 20); + case 7: return load_u8(data + 38); + case 8: return load_u32(data + 24); + case 9: return load_u8(data + 39); + case 10: return load_u32(data + 28); + case 11: return load_u8(data + 40); + case 12: return load_u32(data + 32); + case 13: return load_u8(data + 41); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_536(Seed_ixvm_536 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[layout.auxiliaries + 1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 2] = v_2; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 3] = (v_2 <= 1ULL ? inverse_536_0[v_2] : inverse(goldilocks_sub(v_2, 1ULL))); + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 4] = v_4; + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 5] = v_5; + switch (v_5) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_5 <= 1ULL ? inverse_536_1[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 7] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 8] = v_8; + switch (v_8) { + case 1ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_536_2[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 10] = v_10; + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 11] = v_11; + switch (v_11) { + case 1ULL: { + row[layout.selectors + 3] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_11 <= 1ULL ? inverse_536_3[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(10); + row[layout.auxiliaries + 13] = v_13; + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 14] = v_14; + switch (v_14) { + case 1ULL: { + row[layout.selectors + 4] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 15] = (v_14 <= 1ULL ? inverse_536_4[v_14] : inverse(goldilocks_sub(v_14, 1ULL))); + const uint64_t v_16 = seed.word(12); + row[layout.auxiliaries + 16] = v_16; + const uint64_t v_17 = seed.word(13); + row[layout.auxiliaries + 17] = v_17; + switch (v_17) { + case 1ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 18] = (v_17 <= 1ULL ? inverse_536_5[v_17] : inverse(goldilocks_sub(v_17, 1ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + } + } + } + } + } + } + } + } + } +} +template __global__ void kernel_ixvm_536(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 112; + const Seed_ixvm_536 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_536(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_536(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_536<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_536<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_536(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 19) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 112 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_536); +} + +template struct Seed_ixvm_564 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u32(data + 36); + case 3: return load_u8(data + 112); + case 4: return load_u32(data + 40); + case 5: return load_u32(data + 44); + case 6: return load_u32(data + 48); + case 7: return load_u32(data + 52); + case 8: return load_u32(data + 56); + case 9: return load_u32(data + 60); + case 10: return load_u32(data + 64); + case 11: return load_u32(data + 68); + case 12: return load_u32(data + 72); + case 13: return load_u8(data + 113); + case 14: return load_u32(data + 76); + case 15: return load_u32(data + 80); + case 16: return load_u32(data + 84); + case 17: return load_u32(data + 88); + case 18: return load_u32(data + 92); + case 19: return load_u32(data + 96); + case 20: return load_u32(data + 100); + case 21: return load_u32(data + 104); + case 22: return load_u32(data + 108); + case 23: return load_u64(data + 8); + case 24: return load_u64(data + 16); + case 25: return load_u64(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_564(Seed_ixvm_564 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_13 = seed.word(13); + const uint64_t v_14 = seed.word(14); + const uint64_t v_15 = seed.word(15); + const uint64_t v_16 = seed.word(16); + const uint64_t v_17 = seed.word(17); + const uint64_t v_18 = seed.word(18); + const uint64_t v_19 = seed.word(19); + const uint64_t v_20 = seed.word(20); + const uint64_t v_21 = seed.word(21); + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 11] = v_13; + row[layout.auxiliaries + 12] = v_14; + row[layout.auxiliaries + 13] = v_15; + row[layout.auxiliaries + 14] = v_16; + row[layout.auxiliaries + 15] = v_17; + row[layout.auxiliaries + 16] = v_18; + row[layout.auxiliaries + 17] = v_19; + row[layout.auxiliaries + 18] = v_20; + row[layout.auxiliaries + 19] = v_21; + row[layout.auxiliaries + 20] = v_22; + switch (v_13) { + case 0ULL: { + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 21] = v_23; + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 22] = v_24; + const uint64_t v_25 = seed.word(25); + row[layout.auxiliaries + 23] = v_25; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_564(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 120 : 208; + const Seed_ixvm_564 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_564(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_564(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_564<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_564<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_564(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 24) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 208 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_564); +} + +__device__ __constant__ uint64_t inverse_572_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_572 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 132); + case 2: return load_u32(data + 72); + case 3: return load_u32(data + 76); + case 4: return load_u32(data + 80); + case 5: return load_u32(data + 84); + case 6: return load_u32(data + 88); + case 7: return load_u32(data + 92); + case 8: return load_u8(data + 133); + case 9: return load_u32(data + 96); + case 10: return load_u64(data + 8); + case 11: return load_u64(data + 16); + case 12: return load_u64(data + 24); + case 13: return load_u8(data + 134); + case 14: return load_u32(data + 100); + case 15: return load_u32(data + 104); + case 16: return load_u32(data + 108); + case 17: return load_u32(data + 112); + case 18: return load_u32(data + 116); + case 19: return load_u32(data + 120); + case 20: return load_u8(data + 135); + case 21: return load_u32(data + 124); + case 22: return load_u64(data + 32); + case 23: return load_u64(data + 40); + case 24: return load_u64(data + 48); + case 25: return load_u32(data + 128); + case 26: return load_u8(data + 136); + case 27: return load_u8(data + 137); + case 28: return load_u8(data + 138); + case 29: return load_u64(data + 56); + case 30: return load_u64(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_572(Seed_ixvm_572 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[layout.auxiliaries + 1] = v_25; + const uint64_t v_26 = seed.word(27); + row[layout.auxiliaries + 2] = v_26; + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 3] = v_27; + switch (v_27) { + case 1ULL: { + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + row[layout.auxiliaries + 4] = v_28; + row[layout.auxiliaries + 5] = v_29; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 4] = (v_27 <= 1ULL ? inverse_572_0[v_27] : inverse(goldilocks_sub(v_27, 1ULL))); + const uint64_t v_30 = seed.word(29); + const uint64_t v_31 = seed.word(30); + row[layout.auxiliaries + 5] = v_30; + row[layout.auxiliaries + 6] = v_31; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_572(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 144 : 248; + const Seed_ixvm_572 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_572(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_572(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_572<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_572<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_572(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 25 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 144 : encoding == 0 ? 248 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_572); +} + +__device__ __constant__ uint64_t inverse_574_0[] = {0ULL}; +template struct Seed_ixvm_574 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 236); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 237); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + case 6: return load_u32(data + 184); + case 7: return load_u64(data + 32); + case 8: return load_u32(data + 188); + case 9: return load_u8(data + 238); + case 10: return load_u32(data + 192); + case 11: return load_u32(data + 196); + case 12: return load_u64(data + 40); + case 13: return load_u64(data + 48); + case 14: return load_u32(data + 200); + case 15: return load_u32(data + 204); + case 16: return load_u32(data + 208); + case 17: return load_u64(data + 56); + case 18: return load_u64(data + 64); + case 19: return load_u64(data + 72); + case 20: return load_u64(data + 80); + case 21: return load_u32(data + 212); + case 22: return load_u8(data + 239); + case 23: return load_u32(data + 216); + case 24: return load_u32(data + 220); + case 25: return load_u64(data + 88); + case 26: return load_u64(data + 96); + case 27: return load_u32(data + 224); + case 28: return load_u32(data + 228); + case 29: return load_u32(data + 232); + case 30: return load_u64(data + 104); + case 31: return load_u64(data + 112); + case 32: return load_u64(data + 120); + case 33: return load_u64(data + 128); + case 34: return load_u64(data + 136); + case 35: return load_u64(data + 144); + case 36: return load_u64(data + 152); + case 37: return load_u64(data + 160); + case 38: return load_u64(data + 168); + case 39: return load_u64(data + 176); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_574(Seed_ixvm_574 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = goldilocks_sub(v_4, v_6); + switch (v_7) { + case 0ULL: { + const uint64_t v_8 = seed.word(8); + const uint64_t v_9 = seed.word(9); + row[layout.auxiliaries + 1] = v_8; + row[layout.auxiliaries + 2] = v_9; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_7 <= 0ULL ? inverse_574_0[v_7] : inverse(goldilocks_sub(v_7, 0ULL))); + const uint64_t v_10 = seed.word(8); + row[layout.auxiliaries + 2] = v_10; + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + const uint64_t v_23 = seed.word(21); + row[layout.auxiliaries + 15] = v_23; + const uint64_t v_24 = seed.word(22); + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + const uint64_t v_35 = seed.word(33); + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.auxiliaries + 26] = v_34; + row[layout.auxiliaries + 27] = v_35; + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + row[layout.auxiliaries + 28] = v_36; + row[layout.auxiliaries + 29] = v_37; + const uint64_t v_40 = seed.word(36); + const uint64_t v_41 = seed.word(37); + row[layout.auxiliaries + 30] = v_40; + row[layout.auxiliaries + 31] = v_41; + const uint64_t v_42 = seed.word(38); + const uint64_t v_43 = seed.word(39); + row[layout.auxiliaries + 32] = v_42; + row[layout.auxiliaries + 33] = v_43; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_574(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 240 : 320; + const Seed_ixvm_574 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_574(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_574(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_574<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_574<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_574(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 7 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 34) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 240 : encoding == 0 ? 320 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_574); +} + +__device__ __constant__ uint64_t inverse_584_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_584_1[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_584 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 52); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + case 6: return load_u32(data + 44); + case 7: return load_u32(data + 48); + case 8: return load_u8(data + 53); + case 9: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_584(Seed_ixvm_584 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + switch (v_3) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_3 <= 0ULL ? inverse_584_0[v_3] : inverse(goldilocks_sub(v_3, 0ULL))); + const uint64_t v_5 = seed.word(5); + row[layout.auxiliaries + 2] = v_5; + const uint64_t v_6 = seed.word(6); + row[layout.auxiliaries + 3] = v_6; + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 4] = v_7; + const uint64_t v_8 = seed.word(8); + row[layout.auxiliaries + 5] = v_8; + switch (v_8) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 6] = (v_8 <= 1ULL ? inverse_584_1[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); + const uint64_t v_11 = seed.word(9); + row[layout.auxiliaries + 7] = v_11; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + } +} +template __global__ void kernel_ixvm_584(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 80; + const Seed_ixvm_584 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_584(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_584(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_584<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_584<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_584(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 8) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 80 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_584); +} + +__device__ __constant__ uint64_t inverse_590_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_590 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 104); + case 6: return load_u8(data + 188); + case 7: return load_u64(data + 24); + case 8: return load_u32(data + 108); + case 9: return load_u32(data + 112); + case 10: return load_u32(data + 116); + case 11: return load_u32(data + 120); + case 12: return load_u32(data + 124); + case 13: return load_u32(data + 128); + case 14: return load_u32(data + 132); + case 15: return load_u32(data + 136); + case 16: return load_u8(data + 189); + case 17: return load_u32(data + 140); + case 18: return load_u64(data + 32); + case 19: return load_u64(data + 40); + case 20: return load_u64(data + 48); + case 21: return load_u8(data + 190); + case 22: return load_u32(data + 144); + case 23: return load_u32(data + 148); + case 24: return load_u32(data + 152); + case 25: return load_u32(data + 156); + case 26: return load_u32(data + 160); + case 27: return load_u32(data + 164); + case 28: return load_u8(data + 191); + case 29: return load_u32(data + 168); + case 30: return load_u64(data + 56); + case 31: return load_u64(data + 64); + case 32: return load_u64(data + 72); + case 33: return load_u64(data + 80); + case 34: return load_u64(data + 88); + case 35: return load_u32(data + 172); + case 36: return load_u32(data + 176); + case 37: return load_u32(data + 180); + case 38: return load_u32(data + 184); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_590(Seed_ixvm_590 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 1] = v_5; + row[layout.auxiliaries + 2] = v_6; + row[layout.auxiliaries + 3] = v_7; + switch (v_5) { + case 1ULL: { + const uint64_t v_10 = seed.word(9); + row[layout.auxiliaries + 4] = v_10; + const uint64_t v_11 = seed.word(10); + row[layout.auxiliaries + 5] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(9); + const uint64_t v_13 = seed.word(10); + const uint64_t v_14 = seed.word(11); + const uint64_t v_15 = seed.word(12); + const uint64_t v_16 = seed.word(13); + const uint64_t v_17 = seed.word(14); + const uint64_t v_18 = seed.word(15); + const uint64_t v_19 = seed.word(16); + const uint64_t v_20 = seed.word(17); + const uint64_t v_21 = seed.word(18); + const uint64_t v_22 = seed.word(19); + const uint64_t v_23 = seed.word(20); + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + const uint64_t v_24 = seed.word(21); + const uint64_t v_25 = seed.word(22); + const uint64_t v_26 = seed.word(23); + const uint64_t v_27 = seed.word(24); + const uint64_t v_28 = seed.word(25); + const uint64_t v_29 = seed.word(26); + const uint64_t v_30 = seed.word(27); + const uint64_t v_31 = seed.word(28); + const uint64_t v_32 = seed.word(29); + const uint64_t v_33 = seed.word(30); + const uint64_t v_34 = seed.word(31); + const uint64_t v_35 = seed.word(32); + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.auxiliaries + 26] = v_34; + row[layout.auxiliaries + 27] = v_35; + const uint64_t v_36 = seed.word(33); + const uint64_t v_37 = seed.word(34); + row[layout.auxiliaries + 28] = v_36; + row[layout.auxiliaries + 29] = v_37; + switch (v_36) { + case 1ULL: { + const uint64_t v_38 = seed.word(35); + row[layout.auxiliaries + 30] = v_38; + const uint64_t v_39 = seed.word(36); + row[layout.auxiliaries + 31] = v_39; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 30] = (v_36 <= 1ULL ? inverse_590_0[v_36] : inverse(goldilocks_sub(v_36, 1ULL))); + const uint64_t v_42 = seed.word(35); + row[layout.auxiliaries + 31] = v_42; + const uint64_t v_43 = seed.word(36); + row[layout.auxiliaries + 32] = v_43; + const uint64_t v_44 = seed.word(37); + row[layout.auxiliaries + 33] = v_44; + const uint64_t v_45 = seed.word(38); + row[layout.auxiliaries + 34] = v_45; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_590(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 192 : 312; + const Seed_ixvm_590 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_590(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_590(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_590<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_590<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_590(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 5 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 192 : encoding == 0 ? 312 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_590); +} + +__device__ __constant__ uint64_t inverse_608_0[] = {0ULL}; +template struct Seed_ixvm_608 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 48); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 44); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_608(Seed_ixvm_608 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_608_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + switch (v_2) { + case 5ULL: { + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 6] = v_8; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_608(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 64; + const Seed_ixvm_608 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_608(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_608(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_608<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_608<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_608(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_608); +} + +__device__ __constant__ uint64_t inverse_646_0[] = {9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_646_1[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_646_2[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_646 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 136); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u64(data + 72); + case 11: return load_u64(data + 80); + case 12: return load_u64(data + 88); + case 13: return load_u32(data + 140); + case 14: return load_u8(data + 160); + case 15: return load_u32(data + 144); + case 16: return load_u64(data + 96); + case 17: return load_u64(data + 104); + case 18: return load_u32(data + 148); + case 19: return load_u32(data + 152); + case 20: return load_u8(data + 161); + case 21: return load_u64(data + 112); + case 22: return load_u64(data + 120); + case 23: return load_u64(data + 128); + case 24: return load_u32(data + 156); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_646(Seed_ixvm_646 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + switch (v_0) { + case 7ULL: { + const uint64_t v_15 = seed.word(13); + row[layout.auxiliaries + 1] = v_15; + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + row[layout.auxiliaries + 2] = v_16; + row[layout.auxiliaries + 3] = v_17; + row[layout.auxiliaries + 4] = v_18; + row[layout.auxiliaries + 5] = v_19; + switch (v_16) { + case 5ULL: { + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + row[layout.auxiliaries + 6] = v_20; + row[layout.auxiliaries + 7] = v_21; + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + const uint64_t v_25 = seed.word(23); + row[layout.auxiliaries + 8] = v_22; + row[layout.auxiliaries + 9] = v_23; + row[layout.auxiliaries + 10] = v_24; + row[layout.auxiliaries + 11] = v_25; + switch (v_22) { + case 2ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 12] = (v_22 <= 2ULL ? inverse_646_0[v_22] : inverse(goldilocks_sub(v_22, 2ULL))); + const uint64_t v_27 = seed.word(24); + row[layout.auxiliaries + 13] = v_27; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 6] = (v_16 <= 5ULL ? inverse_646_1[v_16] : inverse(goldilocks_sub(v_16, 5ULL))); + const uint64_t v_29 = seed.word(18); + row[layout.auxiliaries + 7] = v_29; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_646_2[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const uint64_t v_31 = seed.word(13); + row[layout.auxiliaries + 2] = v_31; + row[layout.selectors + 3] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_646(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 168 : 200; + const Seed_ixvm_646 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_646(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_646(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_646<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_646<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_646(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 12 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 168 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_646); +} + +__device__ __constant__ uint64_t inverse_652_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_652_1[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_652_2[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_652 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u32(data + 32); + case 4: return load_u8(data + 48); + case 5: return load_u32(data + 36); + case 6: return load_u64(data + 8); + case 7: return load_u32(data + 40); + case 8: return load_u64(data + 16); + case 9: return load_u32(data + 44); + case 10: return load_u8(data + 49); + case 11: return load_u8(data + 50); + case 12: return load_u8(data + 51); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_652(Seed_ixvm_652 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + switch (v_3) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + switch (v_5) { + case 1ULL: { + const uint64_t v_10 = seed.word(10); + row[layout.auxiliaries + 7] = v_10; + switch (v_10) { + case 1ULL: { + const uint64_t v_11 = seed.word(11); + row[layout.auxiliaries + 8] = v_11; + switch (v_11) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_11 <= 1ULL ? inverse_652_0[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); + const uint64_t v_13 = seed.word(12); + row[layout.auxiliaries + 10] = v_13; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 8] = (v_10 <= 1ULL ? inverse_652_1[v_10] : inverse(goldilocks_sub(v_10, 1ULL))); + const uint64_t v_14 = seed.word(11); + row[layout.auxiliaries + 9] = v_14; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 7] = (v_5 <= 1ULL ? inverse_652_2[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); + const uint64_t v_15 = seed.word(10); + row[layout.auxiliaries + 8] = v_15; + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_652(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 104; + const Seed_ixvm_652 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_652(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_652(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_652<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_652<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_652(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 5 || width < auxiliaries || width - auxiliaries < 11) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_652); +} + +__device__ __constant__ uint64_t inverse_659_1[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_659_3[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_659_4[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_659_5[] = {0ULL}; +template struct Seed_ixvm_659 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 400); + case 2: return load_u8(data + 401); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 402); + case 5: return load_u32(data + 328); + case 6: return load_u64(data + 16); + case 7: return load_u64(data + 24); + case 8: return load_u64(data + 32); + case 9: return load_u8(data + 403); + case 10: return load_u8(data + 404); + case 11: return load_u8(data + 405); + case 12: return load_u8(data + 406); + case 13: return load_u64(data + 40); + case 14: return load_u64(data + 48); + case 15: return load_u64(data + 56); + case 16: return load_u64(data + 64); + case 17: return load_u8(data + 407); + case 18: return load_u8(data + 408); + case 19: return load_u8(data + 409); + case 20: return load_u8(data + 410); + case 21: return load_u32(data + 332); + case 22: return load_u8(data + 411); + case 23: return load_u64(data + 72); + case 24: return load_u64(data + 80); + case 25: return load_u8(data + 412); + case 26: return load_u8(data + 413); + case 27: return load_u8(data + 414); + case 28: return load_u8(data + 415); + case 29: return load_u8(data + 416); + case 30: return load_u8(data + 417); + case 31: return load_u64(data + 88); + case 32: return load_u64(data + 96); + case 33: return load_u8(data + 418); + case 34: return load_u8(data + 419); + case 35: return load_u8(data + 420); + case 36: return load_u8(data + 421); + case 37: return load_u8(data + 422); + case 38: return load_u8(data + 423); + case 39: return load_u64(data + 104); + case 40: return load_u64(data + 112); + case 41: return load_u8(data + 424); + case 42: return load_u8(data + 425); + case 43: return load_u8(data + 426); + case 44: return load_u8(data + 427); + case 45: return load_u8(data + 428); + case 46: return load_u8(data + 429); + case 47: return load_u64(data + 120); + case 48: return load_u32(data + 336); + case 49: return load_u32(data + 340); + case 50: return load_u32(data + 344); + case 51: return load_u32(data + 348); + case 52: return load_u8(data + 430); + case 53: return load_u8(data + 431); + case 54: return load_u32(data + 352); + case 55: return load_u64(data + 128); + case 56: return load_u64(data + 136); + case 57: return load_u64(data + 144); + case 58: return load_u8(data + 432); + case 59: return load_u8(data + 433); + case 60: return load_u8(data + 434); + case 61: return load_u8(data + 435); + case 62: return load_u64(data + 152); + case 63: return load_u64(data + 160); + case 64: return load_u64(data + 168); + case 65: return load_u64(data + 176); + case 66: return load_u8(data + 436); + case 67: return load_u8(data + 437); + case 68: return load_u8(data + 438); + case 69: return load_u8(data + 439); + case 70: return load_u32(data + 356); + case 71: return load_u8(data + 440); + case 72: return load_u64(data + 184); + case 73: return load_u64(data + 192); + case 74: return load_u8(data + 441); + case 75: return load_u8(data + 442); + case 76: return load_u8(data + 443); + case 77: return load_u8(data + 444); + case 78: return load_u8(data + 445); + case 79: return load_u8(data + 446); + case 80: return load_u64(data + 200); + case 81: return load_u64(data + 208); + case 82: return load_u8(data + 447); + case 83: return load_u8(data + 448); + case 84: return load_u8(data + 449); + case 85: return load_u8(data + 450); + case 86: return load_u8(data + 451); + case 87: return load_u8(data + 452); + case 88: return load_u64(data + 216); + case 89: return load_u64(data + 224); + case 90: return load_u8(data + 453); + case 91: return load_u8(data + 454); + case 92: return load_u8(data + 455); + case 93: return load_u8(data + 456); + case 94: return load_u8(data + 457); + case 95: return load_u8(data + 458); + case 96: return load_u64(data + 232); + case 97: return load_u32(data + 360); + case 98: return load_u32(data + 364); + case 99: return load_u32(data + 368); + case 100: return load_u32(data + 372); + case 101: return load_u32(data + 376); + case 102: return load_u8(data + 459); + case 103: return load_u64(data + 240); + case 104: return load_u32(data + 380); + case 105: return load_u64(data + 248); + case 106: return load_u64(data + 256); + case 107: return load_u64(data + 264); + case 108: return load_u64(data + 272); + case 109: return load_u64(data + 280); + case 110: return load_u64(data + 288); + case 111: return load_u64(data + 296); + case 112: return load_u64(data + 304); + case 113: return load_u64(data + 312); + case 114: return load_u32(data + 384); + case 115: return load_u32(data + 388); + case 116: return load_u32(data + 392); + case 117: return load_u32(data + 396); + case 118: return load_u8(data + 460); + case 119: return load_u64(data + 320); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_659(Seed_ixvm_659 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + row[layout.auxiliaries + 6] = v_8; + row[layout.auxiliaries + 7] = v_9; + row[layout.auxiliaries + 8] = v_10; + row[layout.auxiliaries + 9] = v_11; + row[layout.auxiliaries + 10] = v_12; + row[layout.auxiliaries + 11] = v_13; + row[layout.auxiliaries + 12] = v_14; + row[layout.auxiliaries + 13] = v_15; + row[layout.auxiliaries + 14] = v_16; + row[layout.auxiliaries + 15] = v_17; + row[layout.auxiliaries + 16] = v_18; + row[layout.auxiliaries + 17] = v_19; + row[layout.auxiliaries + 18] = v_20; + row[layout.auxiliaries + 19] = v_21; + row[layout.auxiliaries + 20] = v_22; + row[layout.auxiliaries + 21] = v_23; + row[layout.auxiliaries + 22] = v_24; + row[layout.auxiliaries + 23] = v_25; + row[layout.auxiliaries + 24] = v_26; + row[layout.auxiliaries + 25] = v_27; + row[layout.auxiliaries + 26] = v_28; + row[layout.auxiliaries + 27] = v_29; + row[layout.auxiliaries + 28] = v_30; + row[layout.auxiliaries + 29] = v_31; + row[layout.auxiliaries + 30] = v_32; + row[layout.auxiliaries + 31] = v_33; + row[layout.auxiliaries + 32] = v_34; + row[layout.auxiliaries + 33] = v_35; + row[layout.auxiliaries + 34] = v_36; + row[layout.auxiliaries + 35] = v_37; + row[layout.auxiliaries + 36] = v_38; + row[layout.auxiliaries + 37] = v_39; + row[layout.auxiliaries + 38] = v_40; + row[layout.auxiliaries + 39] = v_41; + row[layout.auxiliaries + 40] = v_42; + row[layout.auxiliaries + 41] = v_43; + row[layout.auxiliaries + 42] = v_44; + row[layout.auxiliaries + 43] = v_45; + row[layout.auxiliaries + 44] = v_46; + row[layout.auxiliaries + 45] = v_47; + row[layout.auxiliaries + 46] = v_48; + row[layout.auxiliaries + 47] = v_49; + row[layout.auxiliaries + 48] = v_50; + uint64_t v_53; + switch (v_3) { + default: { + switch (v_3) { + case 8ULL: { + const uint64_t v_52 = seed.word(52); + row[layout.auxiliaries + 49] = v_52; + row[layout.selectors + 0] = 1; + v_53 = v_52; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 49] = (v_3 <= 8ULL ? inverse_659_1[v_3] : inverse(goldilocks_sub(v_3, 8ULL))); + row[layout.selectors + 1] = 1; + v_53 = v_1; + goto continuation_0; + } + } + } + } + continuation_0:; + row[layout.auxiliaries + 50] = v_53; + const uint64_t v_54 = seed.word(53); + const uint64_t v_55 = seed.word(54); + const uint64_t v_56 = seed.word(55); + const uint64_t v_57 = seed.word(56); + const uint64_t v_58 = seed.word(57); + const uint64_t v_59 = seed.word(58); + const uint64_t v_60 = seed.word(59); + const uint64_t v_61 = seed.word(60); + const uint64_t v_62 = seed.word(61); + const uint64_t v_63 = seed.word(62); + const uint64_t v_64 = seed.word(63); + const uint64_t v_65 = seed.word(64); + const uint64_t v_66 = seed.word(65); + const uint64_t v_67 = seed.word(66); + const uint64_t v_68 = seed.word(67); + const uint64_t v_69 = seed.word(68); + const uint64_t v_70 = seed.word(69); + const uint64_t v_71 = seed.word(70); + const uint64_t v_72 = seed.word(71); + const uint64_t v_73 = seed.word(72); + const uint64_t v_74 = seed.word(73); + const uint64_t v_75 = seed.word(74); + const uint64_t v_76 = seed.word(75); + const uint64_t v_77 = seed.word(76); + const uint64_t v_78 = seed.word(77); + const uint64_t v_79 = seed.word(78); + const uint64_t v_80 = seed.word(79); + const uint64_t v_81 = seed.word(80); + const uint64_t v_82 = seed.word(81); + const uint64_t v_83 = seed.word(82); + const uint64_t v_84 = seed.word(83); + const uint64_t v_85 = seed.word(84); + const uint64_t v_86 = seed.word(85); + const uint64_t v_87 = seed.word(86); + const uint64_t v_88 = seed.word(87); + const uint64_t v_89 = seed.word(88); + const uint64_t v_90 = seed.word(89); + const uint64_t v_91 = seed.word(90); + const uint64_t v_92 = seed.word(91); + const uint64_t v_93 = seed.word(92); + const uint64_t v_94 = seed.word(93); + const uint64_t v_95 = seed.word(94); + const uint64_t v_96 = seed.word(95); + const uint64_t v_97 = seed.word(96); + const uint64_t v_98 = seed.word(97); + const uint64_t v_99 = seed.word(98); + const uint64_t v_100 = seed.word(99); + const uint64_t v_101 = seed.word(100); + row[layout.auxiliaries + 51] = v_54; + row[layout.auxiliaries + 52] = v_55; + row[layout.auxiliaries + 53] = v_56; + row[layout.auxiliaries + 54] = v_57; + row[layout.auxiliaries + 55] = v_58; + row[layout.auxiliaries + 56] = v_59; + row[layout.auxiliaries + 57] = v_60; + row[layout.auxiliaries + 58] = v_61; + row[layout.auxiliaries + 59] = v_62; + row[layout.auxiliaries + 60] = v_63; + row[layout.auxiliaries + 61] = v_64; + row[layout.auxiliaries + 62] = v_65; + row[layout.auxiliaries + 63] = v_66; + row[layout.auxiliaries + 64] = v_67; + row[layout.auxiliaries + 65] = v_68; + row[layout.auxiliaries + 66] = v_69; + row[layout.auxiliaries + 67] = v_70; + row[layout.auxiliaries + 68] = v_71; + row[layout.auxiliaries + 69] = v_72; + row[layout.auxiliaries + 70] = v_73; + row[layout.auxiliaries + 71] = v_74; + row[layout.auxiliaries + 72] = v_75; + row[layout.auxiliaries + 73] = v_76; + row[layout.auxiliaries + 74] = v_77; + row[layout.auxiliaries + 75] = v_78; + row[layout.auxiliaries + 76] = v_79; + row[layout.auxiliaries + 77] = v_80; + row[layout.auxiliaries + 78] = v_81; + row[layout.auxiliaries + 79] = v_82; + row[layout.auxiliaries + 80] = v_83; + row[layout.auxiliaries + 81] = v_84; + row[layout.auxiliaries + 82] = v_85; + row[layout.auxiliaries + 83] = v_86; + row[layout.auxiliaries + 84] = v_87; + row[layout.auxiliaries + 85] = v_88; + row[layout.auxiliaries + 86] = v_89; + row[layout.auxiliaries + 87] = v_90; + row[layout.auxiliaries + 88] = v_91; + row[layout.auxiliaries + 89] = v_92; + row[layout.auxiliaries + 90] = v_93; + row[layout.auxiliaries + 91] = v_94; + row[layout.auxiliaries + 92] = v_95; + row[layout.auxiliaries + 93] = v_96; + row[layout.auxiliaries + 94] = v_97; + row[layout.auxiliaries + 95] = v_98; + row[layout.auxiliaries + 96] = v_99; + row[layout.auxiliaries + 97] = v_100; + row[layout.auxiliaries + 98] = v_101; + uint64_t v_125; + switch (v_54) { + default: { + switch (v_54) { + case 8ULL: { + const uint64_t v_103 = seed.word(101); + row[layout.auxiliaries + 99] = v_103; + row[layout.selectors + 2] = 1; + v_125 = v_103; + goto continuation_2; + } + default: { + row[layout.auxiliaries + 99] = (v_54 <= 8ULL ? inverse_659_3[v_54] : inverse(goldilocks_sub(v_54, 8ULL))); + const uint64_t v_104 = seed.word(101); + row[layout.auxiliaries + 100] = v_104; + const uint64_t v_105 = seed.word(102); + const uint64_t v_106 = seed.word(103); + const uint64_t v_107 = seed.word(104); + const uint64_t v_108 = seed.word(105); + const uint64_t v_109 = seed.word(106); + const uint64_t v_110 = seed.word(107); + const uint64_t v_111 = seed.word(108); + const uint64_t v_112 = seed.word(109); + const uint64_t v_113 = seed.word(110); + const uint64_t v_114 = seed.word(111); + const uint64_t v_115 = seed.word(112); + const uint64_t v_116 = seed.word(113); + row[layout.auxiliaries + 101] = v_105; + row[layout.auxiliaries + 102] = v_106; + row[layout.auxiliaries + 103] = v_107; + row[layout.auxiliaries + 104] = v_108; + row[layout.auxiliaries + 105] = v_109; + row[layout.auxiliaries + 106] = v_110; + row[layout.auxiliaries + 107] = v_111; + row[layout.auxiliaries + 108] = v_112; + row[layout.auxiliaries + 109] = v_113; + row[layout.auxiliaries + 110] = v_114; + row[layout.auxiliaries + 111] = v_115; + row[layout.auxiliaries + 112] = v_116; + switch (v_105) { + case 5ULL: { + const uint64_t v_118 = seed.word(114); + row[layout.auxiliaries + 113] = v_118; + const uint64_t v_120 = seed.word(115); + row[layout.auxiliaries + 114] = v_120; + const uint64_t v_121 = seed.word(116); + row[layout.auxiliaries + 115] = v_121; + const uint64_t v_122 = seed.word(117); + row[layout.auxiliaries + 116] = v_122; + row[layout.selectors + 3] = 1; + v_125 = v_122; + goto continuation_2; + } + default: { + row[layout.auxiliaries + 113] = (v_105 <= 5ULL ? inverse_659_4[v_105] : inverse(goldilocks_sub(v_105, 5ULL))); + const uint64_t v_124 = seed.word(114); + row[layout.auxiliaries + 114] = v_124; + row[layout.selectors + 4] = 1; + v_125 = v_124; + goto continuation_2; + } + } + } + } + } + } + continuation_2:; + row[layout.auxiliaries + 117] = v_125; + const uint64_t v_126 = seed.word(118); + row[layout.auxiliaries + 118] = v_126; + switch (v_126) { + case 0ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 119] = (v_126 <= 0ULL ? inverse_659_5[v_126] : inverse(goldilocks_sub(v_126, 0ULL))); + const uint64_t v_127 = seed.word(119); + row[layout.auxiliaries + 120] = v_127; + row[layout.selectors + 6] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_659(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 464 : 960; + const Seed_ixvm_659 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_659(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_659(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_659<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_659<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_659(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 121) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 464 : encoding == 0 ? 960 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_659); +} + +__device__ __constant__ uint64_t inverse_660_0[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_660 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 168); + case 2: return load_u32(data + 136); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 140); + case 5: return load_u8(data + 169); + case 6: return load_u32(data + 144); + case 7: return load_u64(data + 16); + case 8: return load_u64(data + 24); + case 9: return load_u64(data + 32); + case 10: return load_u8(data + 170); + case 11: return load_u8(data + 171); + case 12: return load_u8(data + 172); + case 13: return load_u8(data + 173); + case 14: return load_u64(data + 40); + case 15: return load_u64(data + 48); + case 16: return load_u64(data + 56); + case 17: return load_u64(data + 64); + case 18: return load_u8(data + 174); + case 19: return load_u8(data + 175); + case 20: return load_u8(data + 176); + case 21: return load_u8(data + 177); + case 22: return load_u32(data + 148); + case 23: return load_u8(data + 178); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u8(data + 179); + case 27: return load_u8(data + 180); + case 28: return load_u8(data + 181); + case 29: return load_u8(data + 182); + case 30: return load_u8(data + 183); + case 31: return load_u8(data + 184); + case 32: return load_u64(data + 88); + case 33: return load_u64(data + 96); + case 34: return load_u8(data + 185); + case 35: return load_u8(data + 186); + case 36: return load_u8(data + 187); + case 37: return load_u8(data + 188); + case 38: return load_u8(data + 189); + case 39: return load_u8(data + 190); + case 40: return load_u64(data + 104); + case 41: return load_u64(data + 112); + case 42: return load_u8(data + 191); + case 43: return load_u8(data + 192); + case 44: return load_u8(data + 193); + case 45: return load_u8(data + 194); + case 46: return load_u8(data + 195); + case 47: return load_u8(data + 196); + case 48: return load_u64(data + 120); + case 49: return load_u32(data + 152); + case 50: return load_u32(data + 156); + case 51: return load_u32(data + 160); + case 52: return load_u32(data + 164); + case 53: return load_u64(data + 128); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_660(Seed_ixvm_660 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 1] = v_4; + row[layout.auxiliaries + 2] = v_5; + row[layout.auxiliaries + 3] = v_6; + row[layout.auxiliaries + 4] = v_7; + row[layout.auxiliaries + 5] = v_8; + row[layout.auxiliaries + 6] = v_9; + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + row[layout.auxiliaries + 16] = v_19; + row[layout.auxiliaries + 17] = v_20; + row[layout.auxiliaries + 18] = v_21; + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + row[layout.auxiliaries + 21] = v_24; + row[layout.auxiliaries + 22] = v_25; + row[layout.auxiliaries + 23] = v_26; + row[layout.auxiliaries + 24] = v_27; + row[layout.auxiliaries + 25] = v_28; + row[layout.auxiliaries + 26] = v_29; + row[layout.auxiliaries + 27] = v_30; + row[layout.auxiliaries + 28] = v_31; + row[layout.auxiliaries + 29] = v_32; + row[layout.auxiliaries + 30] = v_33; + row[layout.auxiliaries + 31] = v_34; + row[layout.auxiliaries + 32] = v_35; + row[layout.auxiliaries + 33] = v_36; + row[layout.auxiliaries + 34] = v_37; + row[layout.auxiliaries + 35] = v_38; + row[layout.auxiliaries + 36] = v_39; + row[layout.auxiliaries + 37] = v_40; + row[layout.auxiliaries + 38] = v_41; + row[layout.auxiliaries + 39] = v_42; + row[layout.auxiliaries + 40] = v_43; + row[layout.auxiliaries + 41] = v_44; + row[layout.auxiliaries + 42] = v_45; + row[layout.auxiliaries + 43] = v_46; + row[layout.auxiliaries + 44] = v_47; + row[layout.auxiliaries + 45] = v_48; + row[layout.auxiliaries + 46] = v_49; + row[layout.auxiliaries + 47] = v_50; + row[layout.auxiliaries + 48] = v_51; + switch (v_4) { + default: { + switch (v_4) { + case 8ULL: { + const uint64_t v_53 = seed.word(53); + row[layout.auxiliaries + 49] = v_53; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 49] = (v_4 <= 8ULL ? inverse_660_0[v_4] : inverse(goldilocks_sub(v_4, 8ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + } +} +template __global__ void kernel_ixvm_660(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 200 : 432; + const Seed_ixvm_660 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_660(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_660(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_660<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_660<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_660(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 4 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 50) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 200 : encoding == 0 ? 432 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_660); +} + +__device__ __constant__ uint64_t inverse_711_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_711 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u32(data + 28); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 52); + case 5: return load_u32(data + 32); + case 6: return load_u32(data + 36); + case 7: return load_u8(data + 53); + case 8: return load_u32(data + 40); + case 9: return load_u32(data + 44); + case 10: return load_u32(data + 48); + case 11: return load_u64(data + 16); + case 12: return load_u8(data + 54); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_711(Seed_ixvm_711 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + switch (v_3) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_7 = seed.word(7); + const uint64_t v_8 = seed.word(8); + const uint64_t v_9 = seed.word(9); + row[layout.auxiliaries + 4] = v_7; + row[layout.auxiliaries + 5] = v_8; + row[layout.auxiliaries + 6] = v_9; + switch (v_7) { + case 1ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(10); + row[layout.auxiliaries + 7] = v_12; + const uint64_t v_13 = seed.word(11); + row[layout.auxiliaries + 8] = v_13; + switch (v_13) { + case 1ULL: { + const uint64_t v_14 = seed.word(12); + row[layout.auxiliaries + 9] = v_14; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_13 <= 1ULL ? inverse_711_0[v_13] : inverse(goldilocks_sub(v_13, 1ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_711(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 56 : 104; + const Seed_ixvm_711 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_711(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_711(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_711<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_711<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_711(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 10) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 104 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_711); +} + +__device__ __constant__ uint64_t inverse_719_0[] = {0ULL}; +template struct Seed_ixvm_719 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 176); + case 2: return load_u8(data + 177); + case 3: return load_u32(data + 144); + case 4: return load_u8(data + 178); + case 5: return load_u64(data + 8); + case 6: return load_u64(data + 16); + case 7: return load_u64(data + 24); + case 8: return load_u8(data + 179); + case 9: return load_u8(data + 180); + case 10: return load_u64(data + 32); + case 11: return load_u8(data + 181); + case 12: return load_u64(data + 40); + case 13: return load_u32(data + 148); + case 14: return load_u64(data + 48); + case 15: return load_u32(data + 152); + case 16: return load_u64(data + 56); + case 17: return load_u32(data + 156); + case 18: return load_u8(data + 182); + case 19: return load_u64(data + 64); + case 20: return load_u32(data + 160); + case 21: return load_u64(data + 72); + case 22: return load_u64(data + 80); + case 23: return load_u64(data + 88); + case 24: return load_u64(data + 96); + case 25: return load_u64(data + 104); + case 26: return load_u64(data + 112); + case 27: return load_u64(data + 120); + case 28: return load_u64(data + 128); + case 29: return load_u64(data + 136); + case 30: return load_u32(data + 164); + case 31: return load_u32(data + 168); + case 32: return load_u32(data + 172); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_719(Seed_ixvm_719 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 1] = v_13; + switch (v_0) { + case 0ULL: { + const uint64_t v_16 = seed.word(15); + row[layout.auxiliaries + 2] = v_16; + const uint64_t v_17 = seed.word(16); + row[layout.auxiliaries + 3] = v_17; + row[layout.selectors + 0] = 1; + return 0; + } + case 1ULL: { + const uint64_t v_20 = seed.word(15); + row[layout.auxiliaries + 2] = v_20; + const uint64_t v_21 = seed.word(16); + row[layout.auxiliaries + 3] = v_21; + row[layout.selectors + 1] = 1; + return 0; + } + case 2ULL: { + const uint64_t v_24 = seed.word(15); + row[layout.auxiliaries + 2] = v_24; + const uint64_t v_25 = seed.word(16); + row[layout.auxiliaries + 3] = v_25; + const uint64_t v_26 = seed.word(17); + row[layout.auxiliaries + 4] = v_26; + const uint64_t v_27 = seed.word(18); + row[layout.auxiliaries + 5] = v_27; + row[layout.selectors + 2] = 1; + return 0; + } + case 3ULL: { + const uint64_t v_30 = seed.word(15); + row[layout.auxiliaries + 2] = v_30; + const uint64_t v_31 = seed.word(16); + row[layout.auxiliaries + 3] = v_31; + row[layout.selectors + 3] = 1; + return 0; + } + case 4ULL: { + const uint64_t v_34 = seed.word(15); + row[layout.auxiliaries + 2] = v_34; + const uint64_t v_35 = seed.word(16); + row[layout.auxiliaries + 3] = v_35; + row[layout.selectors + 4] = 1; + return 0; + } + case 5ULL: { + const uint64_t v_38 = seed.word(15); + row[layout.auxiliaries + 2] = v_38; + const uint64_t v_39 = seed.word(16); + row[layout.auxiliaries + 3] = v_39; + row[layout.selectors + 5] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_42 = seed.word(15); + row[layout.auxiliaries + 2] = v_42; + const uint64_t v_43 = seed.word(16); + row[layout.auxiliaries + 3] = v_43; + const uint64_t v_44 = seed.word(17); + row[layout.auxiliaries + 4] = v_44; + const uint64_t v_45 = seed.word(18); + const uint64_t v_46 = seed.word(19); + const uint64_t v_47 = seed.word(20); + const uint64_t v_48 = seed.word(21); + const uint64_t v_49 = seed.word(22); + const uint64_t v_50 = seed.word(23); + const uint64_t v_51 = seed.word(24); + const uint64_t v_52 = seed.word(25); + const uint64_t v_53 = seed.word(26); + const uint64_t v_54 = seed.word(27); + const uint64_t v_55 = seed.word(28); + const uint64_t v_56 = seed.word(29); + row[layout.auxiliaries + 5] = v_45; + row[layout.auxiliaries + 6] = v_46; + row[layout.auxiliaries + 7] = v_47; + row[layout.auxiliaries + 8] = v_48; + row[layout.auxiliaries + 9] = v_49; + row[layout.auxiliaries + 10] = v_50; + row[layout.auxiliaries + 11] = v_51; + row[layout.auxiliaries + 12] = v_52; + row[layout.auxiliaries + 13] = v_53; + row[layout.auxiliaries + 14] = v_54; + row[layout.auxiliaries + 15] = v_55; + row[layout.auxiliaries + 16] = v_56; + switch (v_45) { + case 5ULL: { + const uint64_t v_59 = seed.word(30); + row[layout.auxiliaries + 17] = v_59; + const uint64_t v_60 = seed.word(31); + row[layout.auxiliaries + 18] = v_60; + switch (v_51) { + case 0ULL: { + const uint64_t v_62 = seed.word(32); + row[layout.auxiliaries + 19] = v_62; + row[layout.selectors + 6] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 19] = (v_51 <= 0ULL ? inverse_719_0[v_51] : inverse(goldilocks_sub(v_51, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + return 2; + } + } + } + case 7ULL: { + const uint64_t v_65 = seed.word(15); + row[layout.auxiliaries + 2] = v_65; + const uint64_t v_66 = seed.word(16); + row[layout.auxiliaries + 3] = v_66; + row[layout.selectors + 8] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_719(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 184 : 264; + const Seed_ixvm_719 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_719(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_719(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_719<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_719<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_719(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 13 || auxiliaries < selectors || auxiliaries - selectors < 9 || width < auxiliaries || width - auxiliaries < 20) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_719); +} + +__device__ __constant__ uint64_t inverse_727_0[] = {0ULL}; +template struct Seed_ixvm_727 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 32); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 28); + case 6: return load_u8(data + 33); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_727(Seed_ixvm_727 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = goldilocks_sub(v_3, v_1); + switch (v_6) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 4] = (v_6 <= 0ULL ? inverse_727_0[v_6] : inverse(goldilocks_sub(v_6, 0ULL))); + const uint64_t v_8 = seed.word(6); + row[layout.auxiliaries + 5] = v_8; + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_727(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 56; + const Seed_ixvm_727 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_727(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_727(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_727<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_727<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_727(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_727); +} + +__device__ __constant__ uint64_t inverse_728_1[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_728_2[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL}; +__device__ __constant__ uint64_t inverse_728_3[] = {3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL, 9223372034707292161ULL}; +__device__ __constant__ uint64_t inverse_728_4[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL, 9223372034707292161ULL, 12297829379609722881ULL, 13835058052060938241ULL}; +__device__ __constant__ uint64_t inverse_728_5[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL, 9223372034707292161ULL, 12297829379609722881ULL}; +template struct Seed_ixvm_728 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 120); + case 2: return load_u8(data + 121); + case 3: return load_u32(data + 80); + case 4: return load_u64(data + 8); + case 5: return load_u64(data + 16); + case 6: return load_u64(data + 24); + case 7: return load_u8(data + 122); + case 8: return load_u8(data + 123); + case 9: return load_u8(data + 124); + case 10: return load_u8(data + 125); + case 11: return load_u8(data + 126); + case 12: return load_u32(data + 84); + case 13: return load_u32(data + 88); + case 14: return load_u32(data + 92); + case 15: return load_u8(data + 127); + case 16: return load_u8(data + 128); + case 17: return load_u8(data + 129); + case 18: return load_u8(data + 130); + case 19: return load_u8(data + 131); + case 20: return load_u8(data + 132); + case 21: return load_u64(data + 32); + case 22: return load_u64(data + 40); + case 23: return load_u8(data + 133); + case 24: return load_u8(data + 134); + case 25: return load_u8(data + 135); + case 26: return load_u8(data + 136); + case 27: return load_u8(data + 137); + case 28: return load_u8(data + 138); + case 29: return load_u64(data + 48); + case 30: return load_u64(data + 56); + case 31: return load_u8(data + 139); + case 32: return load_u8(data + 140); + case 33: return load_u8(data + 141); + case 34: return load_u8(data + 142); + case 35: return load_u8(data + 143); + case 36: return load_u8(data + 144); + case 37: return load_u64(data + 64); + case 38: return load_u64(data + 72); + case 39: return load_u8(data + 145); + case 40: return load_u8(data + 146); + case 41: return load_u8(data + 147); + case 42: return load_u8(data + 148); + case 43: return load_u8(data + 149); + case 44: return load_u8(data + 150); + case 45: return load_u32(data + 96); + case 46: return load_u32(data + 100); + case 47: return load_u32(data + 104); + case 48: return load_u32(data + 108); + case 49: return load_u32(data + 112); + case 50: return load_u32(data + 116); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_728(Seed_ixvm_728 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + row[layout.auxiliaries + 37] = v_37; + row[layout.auxiliaries + 38] = v_38; + row[layout.auxiliaries + 39] = v_39; + row[layout.auxiliaries + 40] = v_40; + row[layout.auxiliaries + 41] = v_41; + row[layout.auxiliaries + 42] = v_42; + row[layout.auxiliaries + 43] = v_43; + row[layout.auxiliaries + 44] = v_44; + row[layout.auxiliaries + 45] = v_45; + row[layout.auxiliaries + 46] = v_46; + row[layout.auxiliaries + 47] = v_47; + row[layout.auxiliaries + 48] = v_48; + switch (v_1) { + default: { + switch (v_1) { + case 8ULL: { + row[layout.selectors + 0] = 1; + goto continuation_0; + } + case 7ULL: { + switch (v_2) { + default: { + row[layout.selectors + 1] = 1; + goto continuation_0; + } + } + } + case 6ULL: { + switch (v_2) { + default: { + row[layout.selectors + 2] = 1; + goto continuation_0; + } + } + } + case 4ULL: { + switch (v_2) { + default: { + row[layout.selectors + 3] = 1; + goto continuation_0; + } + } + } + case 5ULL: { + switch (v_2) { + default: { + row[layout.selectors + 4] = 1; + goto continuation_0; + } + } + } + default: { + row[layout.auxiliaries + 49] = (v_1 <= 8ULL ? inverse_728_1[v_1] : inverse(goldilocks_sub(v_1, 8ULL))); + row[layout.auxiliaries + 50] = (v_1 <= 8ULL ? inverse_728_2[v_1] : inverse(goldilocks_sub(v_1, 7ULL))); + row[layout.auxiliaries + 51] = (v_1 <= 8ULL ? inverse_728_3[v_1] : inverse(goldilocks_sub(v_1, 6ULL))); + row[layout.auxiliaries + 52] = (v_1 <= 8ULL ? inverse_728_4[v_1] : inverse(goldilocks_sub(v_1, 4ULL))); + row[layout.auxiliaries + 53] = (v_1 <= 8ULL ? inverse_728_5[v_1] : inverse(goldilocks_sub(v_1, 5ULL))); + row[layout.selectors + 5] = 1; + goto continuation_0; + } + } + continuation_0:; + const uint64_t v_50 = seed.word(50); + row[layout.auxiliaries + 54] = v_50; + row[layout.selectors + 6] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_728(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 152 : 408; + const Seed_ixvm_728 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_728(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_728(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_728<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_728<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_728(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 55) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 152 : encoding == 0 ? 408 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_728); +} + +__device__ __constant__ uint64_t inverse_729_1[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_729 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 16); + case 2: return load_u32(data + 20); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 28); + case 5: return load_u8(data + 29); + case 6: return load_u32(data + 24); + case 7: return load_u8(data + 30); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_729(Seed_ixvm_729 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 1] = v_3; + row[layout.auxiliaries + 2] = v_4; + row[layout.auxiliaries + 3] = v_5; + switch (v_3) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 4] = v_6; + switch (v_6) { + case 1ULL: { + row[layout.selectors + 1] = 1; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 5] = (v_6 <= 1ULL ? inverse_729_1[v_6] : inverse(goldilocks_sub(v_6, 1ULL))); + row[layout.selectors + 2] = 1; + goto continuation_0; + } + } + continuation_0:; + row[layout.selectors + 3] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_729(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 32 : 64; + const Seed_ixvm_729 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_729(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_729(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_729<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_729<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_729(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 32 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_729); +} + +template struct Seed_ixvm_736 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 80); + case 2: return load_u8(data + 116); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 84); + case 5: return load_u64(data + 16); + case 6: return load_u32(data + 88); + case 7: return load_u32(data + 92); + case 8: return load_u8(data + 117); + case 9: return load_u32(data + 96); + case 10: return load_u32(data + 100); + case 11: return load_u8(data + 118); + case 12: return load_u8(data + 119); + case 13: return load_u32(data + 104); + case 14: return load_u64(data + 24); + case 15: return load_u32(data + 108); + case 16: return load_u32(data + 112); + case 17: return load_u64(data + 32); + case 18: return load_u64(data + 40); + case 19: return load_u64(data + 48); + case 20: return load_u64(data + 56); + case 21: return load_u64(data + 64); + case 22: return load_u64(data + 72); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_736(Seed_ixvm_736 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_7; + row[layout.auxiliaries + 2] = v_8; + row[layout.auxiliaries + 3] = v_9; + switch (v_7) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_11 = seed.word(11); + const uint64_t v_12 = seed.word(12); + const uint64_t v_13 = seed.word(13); + const uint64_t v_14 = seed.word(14); + const uint64_t v_15 = seed.word(15); + const uint64_t v_16 = seed.word(16); + row[layout.auxiliaries + 4] = v_11; + row[layout.auxiliaries + 5] = v_12; + row[layout.auxiliaries + 6] = v_13; + row[layout.auxiliaries + 7] = v_14; + row[layout.auxiliaries + 8] = v_15; + row[layout.auxiliaries + 9] = v_16; + const uint64_t v_17 = seed.word(17); + const uint64_t v_18 = seed.word(18); + const uint64_t v_19 = seed.word(19); + const uint64_t v_20 = seed.word(20); + const uint64_t v_21 = seed.word(21); + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 10] = v_17; + row[layout.auxiliaries + 11] = v_18; + row[layout.auxiliaries + 12] = v_19; + row[layout.auxiliaries + 13] = v_20; + row[layout.auxiliaries + 14] = v_21; + row[layout.auxiliaries + 15] = v_22; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_736(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 120 : 184; + const Seed_ixvm_736 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_736(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_736(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_736<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_736<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_736(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 7 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 184 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_736); +} + +__device__ __constant__ uint64_t inverse_739_1[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_739 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 56); + case 2: return load_u32(data + 60); + case 3: return load_u64(data + 8); + case 4: return load_u8(data + 92); + case 5: return load_u64(data + 16); + case 6: return load_u32(data + 64); + case 7: return load_u64(data + 24); + case 8: return load_u32(data + 68); + case 9: return load_u32(data + 72); + case 10: return load_u8(data + 93); + case 11: return load_u64(data + 32); + case 12: return load_u32(data + 76); + case 13: return load_u64(data + 40); + case 14: return load_u32(data + 80); + case 15: return load_u32(data + 84); + case 16: return load_u64(data + 48); + case 17: return load_u8(data + 94); + case 18: return load_u8(data + 95); + case 19: return load_u32(data + 88); + case 20: return load_u8(data + 96); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_739(Seed_ixvm_739 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + row[layout.auxiliaries + 1] = v_16; + row[layout.auxiliaries + 2] = v_17; + row[layout.auxiliaries + 3] = v_18; + switch (v_16) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_19 = seed.word(20); + row[layout.auxiliaries + 4] = v_19; + switch (v_19) { + case 1ULL: { + row[layout.selectors + 1] = 1; + goto continuation_0; + } + default: { + row[layout.auxiliaries + 5] = (v_19 <= 1ULL ? inverse_739_1[v_19] : inverse(goldilocks_sub(v_19, 1ULL))); + row[layout.selectors + 2] = 1; + goto continuation_0; + } + } + continuation_0:; + row[layout.selectors + 3] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_739(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 104 : 168; + const Seed_ixvm_739 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_739(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_739(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_739<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_739<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_739(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 104 : encoding == 0 ? 168 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_739); +} + +template struct Seed_ixvm_740 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 40); + case 2: return load_u8(data + 72); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 44); + case 5: return load_u64(data + 16); + case 6: return load_u32(data + 48); + case 7: return load_u32(data + 52); + case 8: return load_u8(data + 73); + case 9: return load_u64(data + 24); + case 10: return load_u32(data + 56); + case 11: return load_u64(data + 32); + case 12: return load_u32(data + 60); + case 13: return load_u32(data + 64); + case 14: return load_u8(data + 74); + case 15: return load_u8(data + 75); + case 16: return load_u32(data + 68); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_740(Seed_ixvm_740 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + row[layout.auxiliaries + 1] = v_13; + row[layout.auxiliaries + 2] = v_14; + row[layout.auxiliaries + 3] = v_15; + switch (v_13) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_740(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 80 : 136; + const Seed_ixvm_740 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_740(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_740(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_740<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_740<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_740(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 13 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 136 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_740); +} + +__device__ __constant__ uint64_t inverse_752_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_752 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 176); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u64(data + 48); + case 8: return load_u64(data + 56); + case 9: return load_u64(data + 64); + case 10: return load_u8(data + 196); + case 11: return load_u64(data + 72); + case 12: return load_u64(data + 80); + case 13: return load_u8(data + 197); + case 14: return load_u8(data + 198); + case 15: return load_u8(data + 199); + case 16: return load_u8(data + 200); + case 17: return load_u8(data + 201); + case 18: return load_u8(data + 202); + case 19: return load_u64(data + 88); + case 20: return load_u64(data + 96); + case 21: return load_u8(data + 203); + case 22: return load_u8(data + 204); + case 23: return load_u8(data + 205); + case 24: return load_u8(data + 206); + case 25: return load_u8(data + 207); + case 26: return load_u8(data + 208); + case 27: return load_u32(data + 180); + case 28: return load_u32(data + 184); + case 29: return load_u64(data + 104); + case 30: return load_u64(data + 112); + case 31: return load_u64(data + 120); + case 32: return load_u64(data + 128); + case 33: return load_u64(data + 136); + case 34: return load_u64(data + 144); + case 35: return load_u64(data + 152); + case 36: return load_u64(data + 160); + case 37: return load_u32(data + 188); + case 38: return load_u64(data + 168); + case 39: return load_u32(data + 192); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_752(Seed_ixvm_752 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_9; + switch (v_9) { + case 1ULL: { + const uint64_t v_11 = seed.word(11); + row[layout.auxiliaries + 2] = v_11; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 2] = (v_9 <= 1ULL ? inverse_752_0[v_9] : inverse(goldilocks_sub(v_9, 1ULL))); + const uint64_t v_12 = seed.word(11); + const uint64_t v_13 = seed.word(12); + const uint64_t v_14 = seed.word(13); + const uint64_t v_15 = seed.word(14); + const uint64_t v_16 = seed.word(15); + const uint64_t v_17 = seed.word(16); + const uint64_t v_18 = seed.word(17); + const uint64_t v_19 = seed.word(18); + const uint64_t v_20 = seed.word(19); + const uint64_t v_21 = seed.word(20); + const uint64_t v_22 = seed.word(21); + const uint64_t v_23 = seed.word(22); + const uint64_t v_24 = seed.word(23); + const uint64_t v_25 = seed.word(24); + const uint64_t v_26 = seed.word(25); + const uint64_t v_27 = seed.word(26); + const uint64_t v_28 = seed.word(27); + const uint64_t v_29 = seed.word(28); + row[layout.auxiliaries + 3] = v_12; + row[layout.auxiliaries + 4] = v_13; + row[layout.auxiliaries + 5] = v_14; + row[layout.auxiliaries + 6] = v_15; + row[layout.auxiliaries + 7] = v_16; + row[layout.auxiliaries + 8] = v_17; + row[layout.auxiliaries + 9] = v_18; + row[layout.auxiliaries + 10] = v_19; + row[layout.auxiliaries + 11] = v_20; + row[layout.auxiliaries + 12] = v_21; + row[layout.auxiliaries + 13] = v_22; + row[layout.auxiliaries + 14] = v_23; + row[layout.auxiliaries + 15] = v_24; + row[layout.auxiliaries + 16] = v_25; + row[layout.auxiliaries + 17] = v_26; + row[layout.auxiliaries + 18] = v_27; + row[layout.auxiliaries + 19] = v_28; + row[layout.auxiliaries + 20] = v_29; + const uint64_t v_30 = seed.word(29); + const uint64_t v_31 = seed.word(30); + const uint64_t v_32 = seed.word(31); + const uint64_t v_33 = seed.word(32); + const uint64_t v_34 = seed.word(33); + const uint64_t v_35 = seed.word(34); + const uint64_t v_36 = seed.word(35); + const uint64_t v_37 = seed.word(36); + row[layout.auxiliaries + 21] = v_30; + row[layout.auxiliaries + 22] = v_31; + row[layout.auxiliaries + 23] = v_32; + row[layout.auxiliaries + 24] = v_33; + row[layout.auxiliaries + 25] = v_34; + row[layout.auxiliaries + 26] = v_35; + row[layout.auxiliaries + 27] = v_36; + row[layout.auxiliaries + 28] = v_37; + const uint64_t v_38 = seed.word(37); + const uint64_t v_39 = seed.word(38); + row[layout.auxiliaries + 29] = v_38; + row[layout.auxiliaries + 30] = v_39; + const uint64_t v_41 = seed.word(39); + row[layout.auxiliaries + 31] = v_41; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_752(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 216 : 320; + const Seed_ixvm_752 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_752(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_752(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_752<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_752<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_752(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 9 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 32) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 216 : encoding == 0 ? 320 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_752); +} + +template struct Seed_ixvm_755 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 104); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u8(data + 116); + case 5: return load_u8(data + 117); + case 6: return load_u8(data + 118); + case 7: return load_u8(data + 119); + case 8: return load_u8(data + 120); + case 9: return load_u8(data + 121); + case 10: return load_u32(data + 108); + case 11: return load_u8(data + 122); + case 12: return load_u64(data + 24); + case 13: return load_u8(data + 123); + case 14: return load_u64(data + 32); + case 15: return load_u64(data + 40); + case 16: return load_u8(data + 124); + case 17: return load_u8(data + 125); + case 18: return load_u8(data + 126); + case 19: return load_u8(data + 127); + case 20: return load_u8(data + 128); + case 21: return load_u8(data + 129); + case 22: return load_u8(data + 130); + case 23: return load_u64(data + 48); + case 24: return load_u64(data + 56); + case 25: return load_u8(data + 131); + case 26: return load_u8(data + 132); + case 27: return load_u8(data + 133); + case 28: return load_u8(data + 134); + case 29: return load_u8(data + 135); + case 30: return load_u8(data + 136); + case 31: return load_u8(data + 137); + case 32: return load_u64(data + 64); + case 33: return load_u64(data + 72); + case 34: return load_u8(data + 138); + case 35: return load_u8(data + 139); + case 36: return load_u8(data + 140); + case 37: return load_u8(data + 141); + case 38: return load_u8(data + 142); + case 39: return load_u8(data + 143); + case 40: return load_u8(data + 144); + case 41: return load_u64(data + 80); + case 42: return load_u64(data + 88); + case 43: return load_u8(data + 145); + case 44: return load_u8(data + 146); + case 45: return load_u8(data + 147); + case 46: return load_u8(data + 148); + case 47: return load_u8(data + 149); + case 48: return load_u8(data + 150); + case 49: return load_u8(data + 151); + case 50: return load_u32(data + 112); + case 51: return load_u64(data + 96); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_755(Seed_ixvm_755 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + row[layout.auxiliaries + 37] = v_37; + row[layout.auxiliaries + 38] = v_38; + row[layout.auxiliaries + 39] = v_39; + row[layout.auxiliaries + 40] = v_40; + row[layout.auxiliaries + 41] = v_41; + row[layout.auxiliaries + 42] = v_42; + row[layout.auxiliaries + 43] = v_43; + row[layout.auxiliaries + 44] = v_44; + row[layout.auxiliaries + 45] = v_45; + row[layout.auxiliaries + 46] = v_46; + row[layout.auxiliaries + 47] = v_47; + row[layout.auxiliaries + 48] = v_48; + row[layout.auxiliaries + 49] = v_49; + row[layout.auxiliaries + 50] = v_50; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_755(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 152 : 416; + const Seed_ixvm_755 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_755(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_755(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_755<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_755<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_755(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 51) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 152 : encoding == 0 ? 416 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_755); +} + +template struct Seed_ixvm_762 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u8(data + 28); + case 3: return load_u8(data + 29); + case 4: return load_u8(data + 30); + case 5: return load_u8(data + 31); + case 6: return load_u8(data + 32); + case 7: return load_u8(data + 33); + case 8: return load_u8(data + 34); + case 9: return load_u8(data + 35); + case 10: return load_u8(data + 36); + case 11: return load_u8(data + 37); + case 12: return load_u8(data + 38); + case 13: return load_u8(data + 39); + case 14: return load_u8(data + 40); + case 15: return load_u8(data + 41); + case 16: return load_u8(data + 42); + case 17: return load_u8(data + 43); + case 18: return load_u8(data + 44); + case 19: return load_u32(data + 12); + case 20: return load_u32(data + 16); + case 21: return load_u32(data + 20); + case 22: return load_u32(data + 24); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_762(Seed_ixvm_762 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + const uint64_t v_20 = seed.word(20); + row[layout.auxiliaries + 19] = v_20; + const uint64_t v_21 = seed.word(21); + row[layout.auxiliaries + 20] = v_21; + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 21] = v_22; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_ixvm_762(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 184; + const Seed_ixvm_762 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_762(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_762(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_762<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_762<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_762(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 184 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_762); +} + +template struct Seed_ixvm_771 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + case 5: return load_u8(data + 116); + case 6: return load_u8(data + 117); + case 7: return load_u8(data + 118); + case 8: return load_u8(data + 119); + case 9: return load_u8(data + 120); + case 10: return load_u8(data + 121); + case 11: return load_u8(data + 122); + case 12: return load_u64(data + 24); + case 13: return load_u64(data + 32); + case 14: return load_u8(data + 123); + case 15: return load_u8(data + 124); + case 16: return load_u8(data + 125); + case 17: return load_u8(data + 126); + case 18: return load_u8(data + 127); + case 19: return load_u8(data + 128); + case 20: return load_u64(data + 40); + case 21: return load_u64(data + 48); + case 22: return load_u8(data + 129); + case 23: return load_u8(data + 130); + case 24: return load_u8(data + 131); + case 25: return load_u8(data + 132); + case 26: return load_u8(data + 133); + case 27: return load_u8(data + 134); + case 28: return load_u32(data + 104); + case 29: return load_u32(data + 108); + case 30: return load_u8(data + 135); + case 31: return load_u64(data + 56); + case 32: return load_u64(data + 64); + case 33: return load_u8(data + 136); + case 34: return load_u8(data + 137); + case 35: return load_u8(data + 138); + case 36: return load_u8(data + 139); + case 37: return load_u8(data + 140); + case 38: return load_u8(data + 141); + case 39: return load_u64(data + 72); + case 40: return load_u32(data + 112); + case 41: return load_u64(data + 80); + case 42: return load_u64(data + 88); + case 43: return load_u8(data + 142); + case 44: return load_u8(data + 143); + case 45: return load_u8(data + 144); + case 46: return load_u8(data + 145); + case 47: return load_u8(data + 146); + case 48: return load_u8(data + 147); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_771(Seed_ixvm_771 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + row[layout.auxiliaries + 1] = v_10; + row[layout.auxiliaries + 2] = v_11; + row[layout.auxiliaries + 3] = v_12; + row[layout.auxiliaries + 4] = v_13; + row[layout.auxiliaries + 5] = v_14; + row[layout.auxiliaries + 6] = v_15; + row[layout.auxiliaries + 7] = v_16; + row[layout.auxiliaries + 8] = v_17; + row[layout.auxiliaries + 9] = v_18; + row[layout.auxiliaries + 10] = v_19; + row[layout.auxiliaries + 11] = v_20; + row[layout.auxiliaries + 12] = v_21; + row[layout.auxiliaries + 13] = v_22; + row[layout.auxiliaries + 14] = v_23; + row[layout.auxiliaries + 15] = v_24; + row[layout.auxiliaries + 16] = v_25; + row[layout.auxiliaries + 17] = v_26; + row[layout.auxiliaries + 18] = v_27; + row[layout.auxiliaries + 19] = v_28; + switch (v_10) { + case 1ULL: { + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + row[layout.auxiliaries + 20] = v_29; + row[layout.auxiliaries + 21] = v_30; + row[layout.auxiliaries + 22] = v_31; + row[layout.auxiliaries + 23] = v_32; + row[layout.auxiliaries + 24] = v_33; + row[layout.auxiliaries + 25] = v_34; + row[layout.auxiliaries + 26] = v_35; + row[layout.auxiliaries + 27] = v_36; + row[layout.auxiliaries + 28] = v_37; + row[layout.auxiliaries + 29] = v_38; + row[layout.auxiliaries + 30] = v_39; + switch (v_29) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 0ULL: { + const uint64_t v_40 = seed.word(30); + const uint64_t v_41 = seed.word(31); + const uint64_t v_42 = seed.word(32); + const uint64_t v_43 = seed.word(33); + const uint64_t v_44 = seed.word(34); + const uint64_t v_45 = seed.word(35); + const uint64_t v_46 = seed.word(36); + const uint64_t v_47 = seed.word(37); + const uint64_t v_48 = seed.word(38); + const uint64_t v_49 = seed.word(39); + const uint64_t v_50 = seed.word(40); + row[layout.auxiliaries + 20] = v_40; + row[layout.auxiliaries + 21] = v_41; + row[layout.auxiliaries + 22] = v_42; + row[layout.auxiliaries + 23] = v_43; + row[layout.auxiliaries + 24] = v_44; + row[layout.auxiliaries + 25] = v_45; + row[layout.auxiliaries + 26] = v_46; + row[layout.auxiliaries + 27] = v_47; + row[layout.auxiliaries + 28] = v_48; + row[layout.auxiliaries + 29] = v_49; + row[layout.auxiliaries + 30] = v_50; + switch (v_40) { + case 0ULL: { + switch (v_11) { + default: { + switch (v_41) { + default: { + const uint64_t v_52 = seed.word(41); + const uint64_t v_53 = seed.word(42); + const uint64_t v_54 = seed.word(43); + const uint64_t v_55 = seed.word(44); + const uint64_t v_56 = seed.word(45); + const uint64_t v_57 = seed.word(46); + const uint64_t v_58 = seed.word(47); + const uint64_t v_59 = seed.word(48); + row[layout.auxiliaries + 31] = v_52; + row[layout.auxiliaries + 32] = v_53; + row[layout.auxiliaries + 33] = v_54; + row[layout.auxiliaries + 34] = v_55; + row[layout.auxiliaries + 35] = v_56; + row[layout.auxiliaries + 36] = v_57; + row[layout.auxiliaries + 37] = v_58; + row[layout.auxiliaries + 38] = v_59; + row[layout.selectors + 1] = 1; + return 0; + } + } + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_771(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 152 : 392; + const Seed_ixvm_771 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_771(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_771(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_771<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_771<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_771(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 10 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 39) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 152 : encoding == 0 ? 392 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_771); +} + +template struct Seed_ixvm_774 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u8(data + 112); + case 4: return load_u64(data + 8); + case 5: return load_u64(data + 16); + case 6: return load_u8(data + 113); + case 7: return load_u8(data + 114); + case 8: return load_u8(data + 115); + case 9: return load_u8(data + 116); + case 10: return load_u8(data + 117); + case 11: return load_u8(data + 118); + case 12: return load_u8(data + 119); + case 13: return load_u64(data + 24); + case 14: return load_u8(data + 120); + case 15: return load_u64(data + 32); + case 16: return load_u64(data + 40); + case 17: return load_u8(data + 121); + case 18: return load_u8(data + 122); + case 19: return load_u8(data + 123); + case 20: return load_u8(data + 124); + case 21: return load_u8(data + 125); + case 22: return load_u8(data + 126); + case 23: return load_u8(data + 127); + case 24: return load_u64(data + 48); + case 25: return load_u64(data + 56); + case 26: return load_u8(data + 128); + case 27: return load_u8(data + 129); + case 28: return load_u8(data + 130); + case 29: return load_u8(data + 131); + case 30: return load_u8(data + 132); + case 31: return load_u8(data + 133); + case 32: return load_u8(data + 134); + case 33: return load_u64(data + 64); + case 34: return load_u64(data + 72); + case 35: return load_u8(data + 135); + case 36: return load_u8(data + 136); + case 37: return load_u8(data + 137); + case 38: return load_u8(data + 138); + case 39: return load_u8(data + 139); + case 40: return load_u8(data + 140); + case 41: return load_u8(data + 141); + case 42: return load_u64(data + 80); + case 43: return load_u64(data + 88); + case 44: return load_u8(data + 142); + case 45: return load_u8(data + 143); + case 46: return load_u8(data + 144); + case 47: return load_u8(data + 145); + case 48: return load_u8(data + 146); + case 49: return load_u8(data + 147); + case 50: return load_u8(data + 148); + case 51: return load_u32(data + 104); + case 52: return load_u32(data + 108); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_774(Seed_ixvm_774 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.auxiliaries + 7] = v_8; + row[layout.auxiliaries + 8] = v_9; + row[layout.auxiliaries + 9] = v_10; + row[layout.auxiliaries + 10] = v_11; + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.auxiliaries + 27] = v_28; + row[layout.auxiliaries + 28] = v_29; + row[layout.auxiliaries + 29] = v_30; + row[layout.auxiliaries + 30] = v_31; + row[layout.auxiliaries + 31] = v_32; + row[layout.auxiliaries + 32] = v_33; + row[layout.auxiliaries + 33] = v_34; + row[layout.auxiliaries + 34] = v_35; + row[layout.auxiliaries + 35] = v_36; + row[layout.auxiliaries + 36] = v_37; + row[layout.auxiliaries + 37] = v_38; + row[layout.auxiliaries + 38] = v_39; + row[layout.auxiliaries + 39] = v_40; + row[layout.auxiliaries + 40] = v_41; + row[layout.auxiliaries + 41] = v_42; + row[layout.auxiliaries + 42] = v_43; + row[layout.auxiliaries + 43] = v_44; + row[layout.auxiliaries + 44] = v_45; + row[layout.auxiliaries + 45] = v_46; + row[layout.auxiliaries + 46] = v_47; + row[layout.auxiliaries + 47] = v_48; + row[layout.auxiliaries + 48] = v_49; + row[layout.auxiliaries + 49] = v_50; + row[layout.auxiliaries + 50] = v_51; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_774(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 152 : 424; + const Seed_ixvm_774 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_774(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_774(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_774<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_774<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_774(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 51) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 152 : encoding == 0 ? 424 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_774); +} + +template struct Seed_ixvm_780 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u64(data + 64); + case 9: return load_u32(data + 416); + case 10: return load_u32(data + 420); + case 11: return load_u32(data + 424); + case 12: return load_u32(data + 428); + case 13: return load_u32(data + 432); + case 14: return load_u32(data + 436); + case 15: return load_u32(data + 440); + case 16: return load_u32(data + 444); + case 17: return load_u64(data + 72); + case 18: return load_u64(data + 80); + case 19: return load_u64(data + 88); + case 20: return load_u64(data + 96); + case 21: return load_u64(data + 104); + case 22: return load_u64(data + 112); + case 23: return load_u64(data + 120); + case 24: return load_u64(data + 128); + case 25: return load_u64(data + 136); + case 26: return load_u64(data + 144); + case 27: return load_u64(data + 152); + case 28: return load_u64(data + 160); + case 29: return load_u64(data + 168); + case 30: return load_u64(data + 176); + case 31: return load_u64(data + 184); + case 32: return load_u64(data + 192); + case 33: return load_u64(data + 200); + case 34: return load_u64(data + 208); + case 35: return load_u64(data + 216); + case 36: return load_u64(data + 224); + case 37: return load_u64(data + 232); + case 38: return load_u64(data + 240); + case 39: return load_u64(data + 248); + case 40: return load_u64(data + 256); + case 41: return load_u64(data + 264); + case 42: return load_u64(data + 272); + case 43: return load_u64(data + 280); + case 44: return load_u64(data + 288); + case 45: return load_u64(data + 296); + case 46: return load_u64(data + 304); + case 47: return load_u64(data + 312); + case 48: return load_u64(data + 320); + case 49: return load_u8(data + 520); + case 50: return load_u8(data + 521); + case 51: return load_u64(data + 328); + case 52: return load_u8(data + 522); + case 53: return load_u8(data + 523); + case 54: return load_u8(data + 524); + case 55: return load_u8(data + 525); + case 56: return load_u8(data + 526); + case 57: return load_u8(data + 527); + case 58: return load_u32(data + 448); + case 59: return load_u8(data + 528); + case 60: return load_u32(data + 452); + case 61: return load_u8(data + 529); + case 62: return load_u32(data + 456); + case 63: return load_u32(data + 460); + case 64: return load_u32(data + 464); + case 65: return load_u32(data + 468); + case 66: return load_u32(data + 472); + case 67: return load_u32(data + 476); + case 68: return load_u8(data + 530); + case 69: return load_u8(data + 531); + case 70: return load_u8(data + 532); + case 71: return load_u64(data + 336); + case 72: return load_u64(data + 344); + case 73: return load_u64(data + 352); + case 74: return load_u32(data + 480); + case 75: return load_u64(data + 360); + case 76: return load_u32(data + 484); + case 77: return load_u32(data + 488); + case 78: return load_u32(data + 492); + case 79: return load_u8(data + 533); + case 80: return load_u32(data + 496); + case 81: return load_u8(data + 534); + case 82: return load_u32(data + 500); + case 83: return load_u8(data + 535); + case 84: return load_u8(data + 536); + case 85: return load_u32(data + 504); + case 86: return load_u8(data + 537); + case 87: return load_u8(data + 538); + case 88: return load_u8(data + 539); + case 89: return load_u64(data + 368); + case 90: return load_u64(data + 376); + case 91: return load_u8(data + 540); + case 92: return load_u8(data + 541); + case 93: return load_u8(data + 542); + case 94: return load_u8(data + 543); + case 95: return load_u8(data + 544); + case 96: return load_u8(data + 545); + case 97: return load_u8(data + 546); + case 98: return load_u64(data + 384); + case 99: return load_u64(data + 392); + case 100: return load_u8(data + 547); + case 101: return load_u8(data + 548); + case 102: return load_u8(data + 549); + case 103: return load_u8(data + 550); + case 104: return load_u8(data + 551); + case 105: return load_u8(data + 552); + case 106: return load_u8(data + 553); + case 107: return load_u64(data + 400); + case 108: return load_u64(data + 408); + case 109: return load_u8(data + 554); + case 110: return load_u8(data + 555); + case 111: return load_u8(data + 556); + case 112: return load_u8(data + 557); + case 113: return load_u8(data + 558); + case 114: return load_u8(data + 559); + case 115: return load_u8(data + 560); + case 116: return load_u32(data + 508); + case 117: return load_u8(data + 561); + case 118: return load_u32(data + 512); + case 119: return load_u32(data + 516); + case 120: return load_u8(data + 562); + case 121: return load_u8(data + 563); + case 122: return load_u8(data + 564); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_780(Seed_ixvm_780 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_9 = seed.word(9); + const uint64_t v_10 = seed.word(10); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + const uint64_t v_11 = seed.word(11); + row[layout.auxiliaries + 3] = v_11; + const uint64_t v_44 = seed.word(12); + row[layout.auxiliaries + 4] = v_44; + const uint64_t v_45 = seed.word(13); + row[layout.auxiliaries + 5] = v_45; + const uint64_t v_46 = seed.word(14); + row[layout.auxiliaries + 6] = v_46; + const uint64_t v_47 = seed.word(15); + row[layout.auxiliaries + 7] = v_47; + const uint64_t v_48 = seed.word(16); + row[layout.auxiliaries + 8] = v_48; + const uint64_t v_49 = seed.word(17); + const uint64_t v_50 = seed.word(18); + const uint64_t v_51 = seed.word(19); + const uint64_t v_52 = seed.word(20); + const uint64_t v_53 = seed.word(21); + const uint64_t v_54 = seed.word(22); + const uint64_t v_55 = seed.word(23); + const uint64_t v_56 = seed.word(24); + const uint64_t v_57 = seed.word(25); + const uint64_t v_58 = seed.word(26); + const uint64_t v_59 = seed.word(27); + const uint64_t v_60 = seed.word(28); + const uint64_t v_61 = seed.word(29); + const uint64_t v_62 = seed.word(30); + const uint64_t v_63 = seed.word(31); + const uint64_t v_64 = seed.word(32); + const uint64_t v_65 = seed.word(33); + const uint64_t v_66 = seed.word(34); + const uint64_t v_67 = seed.word(35); + const uint64_t v_68 = seed.word(36); + const uint64_t v_69 = seed.word(37); + const uint64_t v_70 = seed.word(38); + const uint64_t v_71 = seed.word(39); + const uint64_t v_72 = seed.word(40); + const uint64_t v_73 = seed.word(41); + const uint64_t v_74 = seed.word(42); + const uint64_t v_75 = seed.word(43); + const uint64_t v_76 = seed.word(44); + const uint64_t v_77 = seed.word(45); + const uint64_t v_78 = seed.word(46); + const uint64_t v_79 = seed.word(47); + const uint64_t v_80 = seed.word(48); + row[layout.auxiliaries + 9] = v_49; + row[layout.auxiliaries + 10] = v_50; + row[layout.auxiliaries + 11] = v_51; + row[layout.auxiliaries + 12] = v_52; + row[layout.auxiliaries + 13] = v_53; + row[layout.auxiliaries + 14] = v_54; + row[layout.auxiliaries + 15] = v_55; + row[layout.auxiliaries + 16] = v_56; + row[layout.auxiliaries + 17] = v_57; + row[layout.auxiliaries + 18] = v_58; + row[layout.auxiliaries + 19] = v_59; + row[layout.auxiliaries + 20] = v_60; + row[layout.auxiliaries + 21] = v_61; + row[layout.auxiliaries + 22] = v_62; + row[layout.auxiliaries + 23] = v_63; + row[layout.auxiliaries + 24] = v_64; + row[layout.auxiliaries + 25] = v_65; + row[layout.auxiliaries + 26] = v_66; + row[layout.auxiliaries + 27] = v_67; + row[layout.auxiliaries + 28] = v_68; + row[layout.auxiliaries + 29] = v_69; + row[layout.auxiliaries + 30] = v_70; + row[layout.auxiliaries + 31] = v_71; + row[layout.auxiliaries + 32] = v_72; + row[layout.auxiliaries + 33] = v_73; + row[layout.auxiliaries + 34] = v_74; + row[layout.auxiliaries + 35] = v_75; + row[layout.auxiliaries + 36] = v_76; + row[layout.auxiliaries + 37] = v_77; + row[layout.auxiliaries + 38] = v_78; + row[layout.auxiliaries + 39] = v_79; + row[layout.auxiliaries + 40] = v_80; + const uint64_t v_132 = seed.word(49); + const uint64_t v_133 = seed.word(50); + const uint64_t v_134 = seed.word(51); + const uint64_t v_135 = seed.word(52); + const uint64_t v_136 = seed.word(53); + const uint64_t v_137 = seed.word(54); + const uint64_t v_138 = seed.word(55); + const uint64_t v_139 = seed.word(56); + const uint64_t v_140 = seed.word(57); + const uint64_t v_141 = seed.word(58); + row[layout.auxiliaries + 41] = v_132; + row[layout.auxiliaries + 42] = v_133; + row[layout.auxiliaries + 43] = v_134; + row[layout.auxiliaries + 44] = v_135; + row[layout.auxiliaries + 45] = v_136; + row[layout.auxiliaries + 46] = v_137; + row[layout.auxiliaries + 47] = v_138; + row[layout.auxiliaries + 48] = v_139; + row[layout.auxiliaries + 49] = v_140; + row[layout.auxiliaries + 50] = v_141; + const uint64_t v_148 = seed.word(59); + const uint64_t v_149 = seed.word(60); + row[layout.auxiliaries + 51] = v_148; + row[layout.auxiliaries + 52] = v_149; + const uint64_t v_151 = seed.word(61); + const uint64_t v_152 = seed.word(62); + row[layout.auxiliaries + 53] = v_151; + row[layout.auxiliaries + 54] = v_152; + switch (v_133) { + case 4ULL: { + const uint64_t v_154 = seed.word(63); + const uint64_t v_155 = seed.word(64); + row[layout.auxiliaries + 55] = v_154; + row[layout.auxiliaries + 56] = v_155; + const uint64_t v_156 = seed.word(65); + const uint64_t v_157 = seed.word(66); + const uint64_t v_158 = seed.word(67); + row[layout.auxiliaries + 57] = v_156; + row[layout.auxiliaries + 58] = v_157; + row[layout.auxiliaries + 59] = v_158; + const uint64_t v_159 = seed.word(68); + const uint64_t v_160 = seed.word(69); + const uint64_t v_161 = seed.word(70); + row[layout.auxiliaries + 60] = v_159; + row[layout.auxiliaries + 61] = v_160; + row[layout.auxiliaries + 62] = v_161; + switch (v_156) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_162 = seed.word(71); + row[layout.auxiliaries + 63] = v_162; + const uint64_t v_164 = seed.word(72); + const uint64_t v_165 = seed.word(73); + const uint64_t v_166 = seed.word(74); + const uint64_t v_167 = seed.word(75); + const uint64_t v_168 = seed.word(76); + const uint64_t v_169 = seed.word(77); + row[layout.auxiliaries + 64] = v_164; + row[layout.auxiliaries + 65] = v_165; + row[layout.auxiliaries + 66] = v_166; + row[layout.auxiliaries + 67] = v_167; + row[layout.auxiliaries + 68] = v_168; + row[layout.auxiliaries + 69] = v_169; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + case 5ULL: { + const uint64_t v_172 = seed.word(63); + const uint64_t v_173 = seed.word(64); + row[layout.auxiliaries + 55] = v_172; + row[layout.auxiliaries + 56] = v_173; + const uint64_t v_174 = seed.word(65); + const uint64_t v_175 = seed.word(66); + const uint64_t v_176 = seed.word(67); + row[layout.auxiliaries + 57] = v_174; + row[layout.auxiliaries + 58] = v_175; + row[layout.auxiliaries + 59] = v_176; + const uint64_t v_177 = seed.word(68); + const uint64_t v_178 = seed.word(69); + const uint64_t v_179 = seed.word(70); + row[layout.auxiliaries + 60] = v_177; + row[layout.auxiliaries + 61] = v_178; + row[layout.auxiliaries + 62] = v_179; + row[layout.selectors + 2] = 1; + return 0; + } + case 6ULL: { + const uint64_t v_181 = seed.word(63); + const uint64_t v_182 = seed.word(64); + row[layout.auxiliaries + 55] = v_181; + row[layout.auxiliaries + 56] = v_182; + const uint64_t v_183 = seed.word(65); + const uint64_t v_184 = seed.word(66); + const uint64_t v_185 = seed.word(67); + const uint64_t v_186 = seed.word(68); + const uint64_t v_187 = seed.word(69); + const uint64_t v_188 = seed.word(70); + const uint64_t v_189 = seed.word(71); + const uint64_t v_190 = seed.word(72); + const uint64_t v_191 = seed.word(73); + const uint64_t v_192 = seed.word(74); + const uint64_t v_193 = seed.word(75); + const uint64_t v_194 = seed.word(76); + const uint64_t v_195 = seed.word(77); + const uint64_t v_196 = seed.word(78); + const uint64_t v_197 = seed.word(79); + const uint64_t v_198 = seed.word(80); + const uint64_t v_199 = seed.word(81); + const uint64_t v_200 = seed.word(82); + const uint64_t v_201 = seed.word(83); + const uint64_t v_202 = seed.word(84); + const uint64_t v_203 = seed.word(85); + const uint64_t v_204 = seed.word(86); + const uint64_t v_205 = seed.word(87); + const uint64_t v_206 = seed.word(88); + const uint64_t v_207 = seed.word(89); + const uint64_t v_208 = seed.word(90); + const uint64_t v_209 = seed.word(91); + const uint64_t v_210 = seed.word(92); + const uint64_t v_211 = seed.word(93); + const uint64_t v_212 = seed.word(94); + const uint64_t v_213 = seed.word(95); + const uint64_t v_214 = seed.word(96); + const uint64_t v_215 = seed.word(97); + const uint64_t v_216 = seed.word(98); + const uint64_t v_217 = seed.word(99); + const uint64_t v_218 = seed.word(100); + const uint64_t v_219 = seed.word(101); + const uint64_t v_220 = seed.word(102); + const uint64_t v_221 = seed.word(103); + const uint64_t v_222 = seed.word(104); + const uint64_t v_223 = seed.word(105); + const uint64_t v_224 = seed.word(106); + const uint64_t v_225 = seed.word(107); + const uint64_t v_226 = seed.word(108); + const uint64_t v_227 = seed.word(109); + const uint64_t v_228 = seed.word(110); + const uint64_t v_229 = seed.word(111); + const uint64_t v_230 = seed.word(112); + const uint64_t v_231 = seed.word(113); + const uint64_t v_232 = seed.word(114); + const uint64_t v_233 = seed.word(115); + const uint64_t v_234 = seed.word(116); + const uint64_t v_235 = seed.word(117); + const uint64_t v_236 = seed.word(118); + const uint64_t v_237 = seed.word(119); + row[layout.auxiliaries + 57] = v_183; + row[layout.auxiliaries + 58] = v_184; + row[layout.auxiliaries + 59] = v_185; + row[layout.auxiliaries + 60] = v_186; + row[layout.auxiliaries + 61] = v_187; + row[layout.auxiliaries + 62] = v_188; + row[layout.auxiliaries + 63] = v_189; + row[layout.auxiliaries + 64] = v_190; + row[layout.auxiliaries + 65] = v_191; + row[layout.auxiliaries + 66] = v_192; + row[layout.auxiliaries + 67] = v_193; + row[layout.auxiliaries + 68] = v_194; + row[layout.auxiliaries + 69] = v_195; + row[layout.auxiliaries + 70] = v_196; + row[layout.auxiliaries + 71] = v_197; + row[layout.auxiliaries + 72] = v_198; + row[layout.auxiliaries + 73] = v_199; + row[layout.auxiliaries + 74] = v_200; + row[layout.auxiliaries + 75] = v_201; + row[layout.auxiliaries + 76] = v_202; + row[layout.auxiliaries + 77] = v_203; + row[layout.auxiliaries + 78] = v_204; + row[layout.auxiliaries + 79] = v_205; + row[layout.auxiliaries + 80] = v_206; + row[layout.auxiliaries + 81] = v_207; + row[layout.auxiliaries + 82] = v_208; + row[layout.auxiliaries + 83] = v_209; + row[layout.auxiliaries + 84] = v_210; + row[layout.auxiliaries + 85] = v_211; + row[layout.auxiliaries + 86] = v_212; + row[layout.auxiliaries + 87] = v_213; + row[layout.auxiliaries + 88] = v_214; + row[layout.auxiliaries + 89] = v_215; + row[layout.auxiliaries + 90] = v_216; + row[layout.auxiliaries + 91] = v_217; + row[layout.auxiliaries + 92] = v_218; + row[layout.auxiliaries + 93] = v_219; + row[layout.auxiliaries + 94] = v_220; + row[layout.auxiliaries + 95] = v_221; + row[layout.auxiliaries + 96] = v_222; + row[layout.auxiliaries + 97] = v_223; + row[layout.auxiliaries + 98] = v_224; + row[layout.auxiliaries + 99] = v_225; + row[layout.auxiliaries + 100] = v_226; + row[layout.auxiliaries + 101] = v_227; + row[layout.auxiliaries + 102] = v_228; + row[layout.auxiliaries + 103] = v_229; + row[layout.auxiliaries + 104] = v_230; + row[layout.auxiliaries + 105] = v_231; + row[layout.auxiliaries + 106] = v_232; + row[layout.auxiliaries + 107] = v_233; + row[layout.auxiliaries + 108] = v_234; + row[layout.auxiliaries + 109] = v_235; + row[layout.auxiliaries + 110] = v_236; + row[layout.auxiliaries + 111] = v_237; + const uint64_t v_238 = seed.word(120); + const uint64_t v_239 = seed.word(121); + const uint64_t v_240 = seed.word(122); + row[layout.auxiliaries + 112] = v_238; + row[layout.auxiliaries + 113] = v_239; + row[layout.auxiliaries + 114] = v_240; + row[layout.selectors + 3] = 1; + return 0; + } + case 7ULL: { + const uint64_t v_243 = seed.word(63); + const uint64_t v_244 = seed.word(64); + row[layout.auxiliaries + 55] = v_243; + row[layout.auxiliaries + 56] = v_244; + const uint64_t v_245 = seed.word(65); + const uint64_t v_246 = seed.word(66); + row[layout.auxiliaries + 57] = v_245; + row[layout.auxiliaries + 58] = v_246; + const uint64_t v_247 = seed.word(67); + const uint64_t v_248 = seed.word(68); + const uint64_t v_249 = seed.word(69); + row[layout.auxiliaries + 59] = v_247; + row[layout.auxiliaries + 60] = v_248; + row[layout.auxiliaries + 61] = v_249; + row[layout.selectors + 4] = 1; + return 0; + } + case 9ULL: { + row[layout.selectors + 5] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_780(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 568 : 984; + const Seed_ixvm_780 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_780(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_780(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_780<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_780<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_780(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 8 || auxiliaries < selectors || auxiliaries - selectors < 6 || width < auxiliaries || width - auxiliaries < 115) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 568 : encoding == 0 ? 984 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_780); +} + +template struct Seed_ixvm_783 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 24); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 40); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 28); + case 6: return load_u32(data + 32); + case 7: return load_u32(data + 36); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_783(Seed_ixvm_783 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 4] = v_7; + const uint64_t v_8 = seed.word(7); + row[layout.auxiliaries + 5] = v_8; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_10 = seed.word(6); + row[layout.auxiliaries + 4] = v_10; + const uint64_t v_11 = seed.word(7); + row[layout.auxiliaries + 5] = v_11; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_783(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_783 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_783(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_783(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_783<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_783<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_783(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_783); +} + +template struct Seed_ixvm_784 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 200); + case 2: return load_u8(data + 208); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + case 7: return load_u64(data + 40); + case 8: return load_u64(data + 48); + case 9: return load_u64(data + 56); + case 10: return load_u64(data + 64); + case 11: return load_u32(data + 204); + case 12: return load_u64(data + 72); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + case 15: return load_u64(data + 96); + case 16: return load_u64(data + 104); + case 17: return load_u64(data + 112); + case 18: return load_u64(data + 120); + case 19: return load_u64(data + 128); + case 20: return load_u64(data + 136); + case 21: return load_u64(data + 144); + case 22: return load_u64(data + 152); + case 23: return load_u64(data + 160); + case 24: return load_u64(data + 168); + case 25: return load_u64(data + 176); + case 26: return load_u64(data + 184); + case 27: return load_u64(data + 192); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_784(Seed_ixvm_784 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + switch (v_1) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_12 = seed.word(12); + const uint64_t v_13 = seed.word(13); + const uint64_t v_14 = seed.word(14); + const uint64_t v_15 = seed.word(15); + const uint64_t v_16 = seed.word(16); + const uint64_t v_17 = seed.word(17); + const uint64_t v_18 = seed.word(18); + const uint64_t v_19 = seed.word(19); + row[layout.auxiliaries + 11] = v_12; + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + const uint64_t v_20 = seed.word(20); + const uint64_t v_21 = seed.word(21); + const uint64_t v_22 = seed.word(22); + const uint64_t v_23 = seed.word(23); + const uint64_t v_24 = seed.word(24); + const uint64_t v_25 = seed.word(25); + const uint64_t v_26 = seed.word(26); + const uint64_t v_27 = seed.word(27); + row[layout.auxiliaries + 19] = v_20; + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_784(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 216 : 224; + const Seed_ixvm_784 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_784(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_784(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_784<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_784<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_784(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 27) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 216 : encoding == 0 ? 224 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_784); +} + +__device__ __constant__ uint64_t inverse_787_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_787_1[] = {0ULL}; +template struct Seed_ixvm_787 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 72); + case 2: return load_u8(data + 112); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 76); + case 5: return load_u64(data + 16); + case 6: return load_u32(data + 80); + case 7: return load_u32(data + 84); + case 8: return load_u64(data + 24); + case 9: return load_u8(data + 113); + case 10: return load_u64(data + 32); + case 11: return load_u32(data + 88); + case 12: return load_u64(data + 40); + case 13: return load_u32(data + 92); + case 14: return load_u32(data + 96); + case 15: return load_u8(data + 114); + case 16: return load_u64(data + 48); + case 17: return load_u32(data + 100); + case 18: return load_u64(data + 56); + case 19: return load_u32(data + 104); + case 20: return load_u32(data + 108); + case 21: return load_u64(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_787(Seed_ixvm_787 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + switch (v_1) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + row[layout.auxiliaries + 1] = v_8; + row[layout.auxiliaries + 2] = v_9; + row[layout.auxiliaries + 3] = v_10; + row[layout.auxiliaries + 4] = v_11; + row[layout.auxiliaries + 5] = v_12; + row[layout.auxiliaries + 6] = v_13; + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + row[layout.auxiliaries + 7] = v_14; + row[layout.auxiliaries + 8] = v_15; + row[layout.auxiliaries + 9] = v_16; + row[layout.auxiliaries + 10] = v_17; + row[layout.auxiliaries + 11] = v_18; + row[layout.auxiliaries + 12] = v_19; + if (v_0 > 0xffffffffULL || v_3 > 0xffffffffULL) return 3; + const uint32_t op_2 = uint32_t(v_0) - uint32_t(v_3); + const uint64_t v_20 = uint64_t(v_0 < v_3); + row[layout.auxiliaries + 13] = (v_0 & 0xffffULL); + row[layout.auxiliaries + 14] = ((v_0 >> 16) & 0xffffULL); + row[layout.auxiliaries + 15] = (uint64_t(op_2) & 0xffffULL); + row[layout.auxiliaries + 16] = ((uint64_t(op_2) >> 16) & 0xffffULL); + row[layout.auxiliaries + 17] = (v_3 & 0xffffULL); + row[layout.auxiliaries + 18] = ((v_3 >> 16) & 0xffffULL); + switch (v_20) { + case 1ULL: { + const uint64_t v_21 = seed.word(21); + row[layout.auxiliaries + 19] = v_21; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 19] = (v_20 <= 1ULL ? inverse_787_0[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); + const uint64_t v_22 = goldilocks_sub(v_0, v_3); + switch (v_22) { + case 0ULL: { + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 20] = (v_22 <= 0ULL ? inverse_787_1[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); + const uint64_t v_23 = seed.word(21); + row[layout.auxiliaries + 21] = v_23; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_787(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 120 : 176; + const Seed_ixvm_787 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_787(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_787(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_787<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_787<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_787(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 8 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 176 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_787); +} + +template struct Seed_ixvm_789 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 32); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 44); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 36); + case 6: return load_u64(data + 24); + case 7: return load_u32(data + 40); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_789(Seed_ixvm_789 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_6 = seed.word(6); + row[layout.auxiliaries + 4] = v_6; + const uint64_t v_7 = seed.word(7); + row[layout.auxiliaries + 5] = v_7; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_789(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 64; + const Seed_ixvm_789 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_789(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_789(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_789<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_789<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_789(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 64 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_789); +} + +template struct Seed_ixvm_791 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 216); + case 2: return load_u8(data + 224); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + case 5: return load_u64(data + 24); + case 6: return load_u8(data + 225); + case 7: return load_u8(data + 226); + case 8: return load_u8(data + 227); + case 9: return load_u8(data + 228); + case 10: return load_u8(data + 229); + case 11: return load_u8(data + 230); + case 12: return load_u64(data + 32); + case 13: return load_u64(data + 40); + case 14: return load_u8(data + 231); + case 15: return load_u8(data + 232); + case 16: return load_u8(data + 233); + case 17: return load_u8(data + 234); + case 18: return load_u8(data + 235); + case 19: return load_u8(data + 236); + case 20: return load_u64(data + 48); + case 21: return load_u64(data + 56); + case 22: return load_u8(data + 237); + case 23: return load_u8(data + 238); + case 24: return load_u8(data + 239); + case 25: return load_u8(data + 240); + case 26: return load_u8(data + 241); + case 27: return load_u8(data + 242); + case 28: return load_u64(data + 64); + case 29: return load_u64(data + 72); + case 30: return load_u8(data + 243); + case 31: return load_u8(data + 244); + case 32: return load_u8(data + 245); + case 33: return load_u8(data + 246); + case 34: return load_u8(data + 247); + case 35: return load_u8(data + 248); + case 36: return load_u64(data + 80); + case 37: return load_u32(data + 220); + case 38: return load_u64(data + 88); + case 39: return load_u64(data + 96); + case 40: return load_u64(data + 104); + case 41: return load_u64(data + 112); + case 42: return load_u64(data + 120); + case 43: return load_u64(data + 128); + case 44: return load_u64(data + 136); + case 45: return load_u64(data + 144); + case 46: return load_u64(data + 152); + case 47: return load_u64(data + 160); + case 48: return load_u64(data + 168); + case 49: return load_u64(data + 176); + case 50: return load_u64(data + 184); + case 51: return load_u64(data + 192); + case 52: return load_u64(data + 200); + case 53: return load_u64(data + 208); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_791(Seed_ixvm_791 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + switch (v_1) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_38 = seed.word(38); + const uint64_t v_39 = seed.word(39); + const uint64_t v_40 = seed.word(40); + const uint64_t v_41 = seed.word(41); + const uint64_t v_42 = seed.word(42); + const uint64_t v_43 = seed.word(43); + const uint64_t v_44 = seed.word(44); + const uint64_t v_45 = seed.word(45); + row[layout.auxiliaries + 37] = v_38; + row[layout.auxiliaries + 38] = v_39; + row[layout.auxiliaries + 39] = v_40; + row[layout.auxiliaries + 40] = v_41; + row[layout.auxiliaries + 41] = v_42; + row[layout.auxiliaries + 42] = v_43; + row[layout.auxiliaries + 43] = v_44; + row[layout.auxiliaries + 44] = v_45; + const uint64_t v_46 = seed.word(46); + const uint64_t v_47 = seed.word(47); + const uint64_t v_48 = seed.word(48); + const uint64_t v_49 = seed.word(49); + const uint64_t v_50 = seed.word(50); + const uint64_t v_51 = seed.word(51); + const uint64_t v_52 = seed.word(52); + const uint64_t v_53 = seed.word(53); + row[layout.auxiliaries + 45] = v_46; + row[layout.auxiliaries + 46] = v_47; + row[layout.auxiliaries + 47] = v_48; + row[layout.auxiliaries + 48] = v_49; + row[layout.auxiliaries + 49] = v_50; + row[layout.auxiliaries + 50] = v_51; + row[layout.auxiliaries + 51] = v_52; + row[layout.auxiliaries + 52] = v_53; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_791(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 256 : 432; + const Seed_ixvm_791 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_791(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_791(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_791<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_791<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_791(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 53) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 256 : encoding == 0 ? 432 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_791); +} + +template struct Seed_ixvm_792 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 40); + case 4: return load_u8(data + 44); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_792(Seed_ixvm_792 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[layout.auxiliaries + 1] = v_2; + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + row[layout.auxiliaries + 4] = v_5; + switch (v_3) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_792(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 56; + const Seed_ixvm_792 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_792(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_792(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_792<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_792<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_792(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_792); +} + +template struct Seed_ixvm_796 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 160); + case 2: return load_u8(data + 168); + case 3: return load_u64(data + 8); + case 4: return load_u64(data + 16); + case 5: return load_u8(data + 169); + case 6: return load_u8(data + 170); + case 7: return load_u8(data + 171); + case 8: return load_u8(data + 172); + case 9: return load_u8(data + 173); + case 10: return load_u8(data + 174); + case 11: return load_u64(data + 24); + case 12: return load_u32(data + 164); + case 13: return load_u64(data + 32); + case 14: return load_u64(data + 40); + case 15: return load_u64(data + 48); + case 16: return load_u64(data + 56); + case 17: return load_u64(data + 64); + case 18: return load_u64(data + 72); + case 19: return load_u64(data + 80); + case 20: return load_u64(data + 88); + case 21: return load_u64(data + 96); + case 22: return load_u64(data + 104); + case 23: return load_u64(data + 112); + case 24: return load_u64(data + 120); + case 25: return load_u64(data + 128); + case 26: return load_u64(data + 136); + case 27: return load_u64(data + 144); + case 28: return load_u64(data + 152); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_796(Seed_ixvm_796 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + switch (v_1) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_13 = seed.word(13); + const uint64_t v_14 = seed.word(14); + const uint64_t v_15 = seed.word(15); + const uint64_t v_16 = seed.word(16); + const uint64_t v_17 = seed.word(17); + const uint64_t v_18 = seed.word(18); + const uint64_t v_19 = seed.word(19); + const uint64_t v_20 = seed.word(20); + row[layout.auxiliaries + 12] = v_13; + row[layout.auxiliaries + 13] = v_14; + row[layout.auxiliaries + 14] = v_15; + row[layout.auxiliaries + 15] = v_16; + row[layout.auxiliaries + 16] = v_17; + row[layout.auxiliaries + 17] = v_18; + row[layout.auxiliaries + 18] = v_19; + row[layout.auxiliaries + 19] = v_20; + const uint64_t v_21 = seed.word(21); + const uint64_t v_22 = seed.word(22); + const uint64_t v_23 = seed.word(23); + const uint64_t v_24 = seed.word(24); + const uint64_t v_25 = seed.word(25); + const uint64_t v_26 = seed.word(26); + const uint64_t v_27 = seed.word(27); + const uint64_t v_28 = seed.word(28); + row[layout.auxiliaries + 20] = v_21; + row[layout.auxiliaries + 21] = v_22; + row[layout.auxiliaries + 22] = v_23; + row[layout.auxiliaries + 23] = v_24; + row[layout.auxiliaries + 24] = v_25; + row[layout.auxiliaries + 25] = v_26; + row[layout.auxiliaries + 26] = v_27; + row[layout.auxiliaries + 27] = v_28; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_796(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 232; + const Seed_ixvm_796 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_796(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_796(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_796<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_796<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_796(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 28) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 232 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_796); +} + +__device__ __constant__ uint64_t inverse_801_0[] = {0ULL}; +template struct Seed_ixvm_801 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u32(data + 40); + case 4: return load_u8(data + 44); + case 5: return load_u64(data + 24); + case 6: return load_u64(data + 32); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_801(Seed_ixvm_801 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_801_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_4 = seed.word(3); + row[layout.auxiliaries + 2] = v_4; + const uint64_t v_5 = seed.word(4); + const uint64_t v_6 = seed.word(5); + const uint64_t v_7 = seed.word(6); + row[layout.auxiliaries + 3] = v_5; + row[layout.auxiliaries + 4] = v_6; + row[layout.auxiliaries + 5] = v_7; + switch (v_5) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + } +} +template __global__ void kernel_ixvm_801(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 48 : 56; + const Seed_ixvm_801 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_801(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_801(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_801<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_801<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_801(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 6) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 56 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_801); +} + +__device__ __constant__ uint64_t inverse_807_0[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_807_1[] = {0ULL}; +template struct Seed_ixvm_807 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 112); + case 2: return load_u64(data + 8); + case 3: return load_u8(data + 176); + case 4: return load_u64(data + 16); + case 5: return load_u32(data + 116); + case 6: return load_u64(data + 24); + case 7: return load_u32(data + 120); + case 8: return load_u32(data + 124); + case 9: return load_u32(data + 128); + case 10: return load_u64(data + 32); + case 11: return load_u32(data + 132); + case 12: return load_u64(data + 40); + case 13: return load_u32(data + 136); + case 14: return load_u32(data + 140); + case 15: return load_u8(data + 177); + case 16: return load_u64(data + 48); + case 17: return load_u32(data + 144); + case 18: return load_u64(data + 56); + case 19: return load_u32(data + 148); + case 20: return load_u32(data + 152); + case 21: return load_u32(data + 156); + case 22: return load_u64(data + 64); + case 23: return load_u64(data + 72); + case 24: return load_u64(data + 80); + case 25: return load_u32(data + 160); + case 26: return load_u32(data + 164); + case 27: return load_u8(data + 178); + case 28: return load_u64(data + 88); + case 29: return load_u64(data + 96); + case 30: return load_u64(data + 104); + case 31: return load_u32(data + 168); + case 32: return load_u32(data + 172); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_807(Seed_ixvm_807 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + switch (v_2) { + case 1ULL: { + const uint64_t v_10 = seed.word(9); + row[layout.auxiliaries + 1] = v_10; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 1] = v_11; + row[layout.auxiliaries + 2] = v_12; + row[layout.auxiliaries + 3] = v_13; + row[layout.auxiliaries + 4] = v_14; + row[layout.auxiliaries + 5] = v_15; + row[layout.auxiliaries + 6] = v_16; + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + row[layout.auxiliaries + 7] = v_17; + row[layout.auxiliaries + 8] = v_18; + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + row[layout.auxiliaries + 12] = v_22; + if (v_0 > 0xffffffffULL || v_4 > 0xffffffffULL) return 3; + const uint32_t op_5 = uint32_t(v_0) - uint32_t(v_4); + const uint64_t v_23 = uint64_t(v_0 < v_4); + row[layout.auxiliaries + 13] = (v_0 & 0xffffULL); + row[layout.auxiliaries + 14] = ((v_0 >> 16) & 0xffffULL); + row[layout.auxiliaries + 15] = (uint64_t(op_5) & 0xffffULL); + row[layout.auxiliaries + 16] = ((uint64_t(op_5) >> 16) & 0xffffULL); + row[layout.auxiliaries + 17] = (v_4 & 0xffffULL); + row[layout.auxiliaries + 18] = ((v_4 >> 16) & 0xffffULL); + switch (v_23) { + case 1ULL: { + const uint64_t v_24 = seed.word(21); + const uint64_t v_25 = seed.word(22); + const uint64_t v_26 = seed.word(23); + const uint64_t v_27 = seed.word(24); + const uint64_t v_28 = seed.word(25); + const uint64_t v_29 = seed.word(26); + row[layout.auxiliaries + 19] = v_24; + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + row[layout.auxiliaries + 22] = v_27; + row[layout.auxiliaries + 23] = v_28; + row[layout.auxiliaries + 24] = v_29; + const uint64_t v_30 = seed.word(27); + const uint64_t v_31 = seed.word(28); + const uint64_t v_32 = seed.word(29); + const uint64_t v_33 = seed.word(30); + const uint64_t v_34 = seed.word(31); + const uint64_t v_35 = seed.word(32); + row[layout.auxiliaries + 25] = v_30; + row[layout.auxiliaries + 26] = v_31; + row[layout.auxiliaries + 27] = v_32; + row[layout.auxiliaries + 28] = v_33; + row[layout.auxiliaries + 29] = v_34; + row[layout.auxiliaries + 30] = v_35; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 19] = (v_23 <= 1ULL ? inverse_807_0[v_23] : inverse(goldilocks_sub(v_23, 1ULL))); + const uint64_t v_36 = goldilocks_sub(v_0, v_4); + switch (v_36) { + case 0ULL: { + const uint64_t v_38 = seed.word(21); + row[layout.auxiliaries + 20] = v_38; + const uint64_t v_39 = seed.word(22); + row[layout.auxiliaries + 21] = v_39; + row[layout.selectors + 2] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 20] = (v_36 <= 0ULL ? inverse_807_1[v_36] : inverse(goldilocks_sub(v_36, 0ULL))); + const uint64_t v_40 = seed.word(21); + const uint64_t v_41 = seed.word(22); + const uint64_t v_42 = seed.word(23); + const uint64_t v_43 = seed.word(24); + const uint64_t v_44 = seed.word(25); + const uint64_t v_45 = seed.word(26); + row[layout.auxiliaries + 21] = v_40; + row[layout.auxiliaries + 22] = v_41; + row[layout.auxiliaries + 23] = v_42; + row[layout.auxiliaries + 24] = v_43; + row[layout.auxiliaries + 25] = v_44; + row[layout.auxiliaries + 26] = v_45; + const uint64_t v_46 = seed.word(27); + const uint64_t v_47 = seed.word(28); + const uint64_t v_48 = seed.word(29); + const uint64_t v_49 = seed.word(30); + const uint64_t v_50 = seed.word(31); + const uint64_t v_51 = seed.word(32); + row[layout.auxiliaries + 27] = v_46; + row[layout.auxiliaries + 28] = v_47; + row[layout.auxiliaries + 29] = v_48; + row[layout.auxiliaries + 30] = v_49; + row[layout.auxiliaries + 31] = v_50; + row[layout.auxiliaries + 32] = v_51; + row[layout.selectors + 3] = 1; + return 0; + } + } + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_ixvm_807(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 184 : 264; + const Seed_ixvm_807 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_807(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_807(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_807<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_807<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_807(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 8 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 33) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_807); +} + +__device__ __constant__ uint64_t inverse_808_0[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_ixvm_808 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u64(data + 16); + case 3: return load_u64(data + 24); + case 4: return load_u64(data + 32); + case 5: return load_u64(data + 40); + case 6: return load_u64(data + 48); + case 7: return load_u64(data + 56); + case 8: return load_u32(data + 112); + case 9: return load_u32(data + 116); + case 10: return load_u64(data + 64); + case 11: return load_u64(data + 72); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u32(data + 120); + case 15: return load_u32(data + 124); + case 16: return load_u32(data + 128); + case 17: return load_u32(data + 132); + case 18: return load_u64(data + 96); + case 19: return load_u64(data + 104); + case 20: return load_u32(data + 136); + case 21: return load_u32(data + 140); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_ixvm_808(Seed_ixvm_808 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + switch (v_0) { + case 1ULL: { + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + row[layout.auxiliaries + 1] = v_15; + row[layout.auxiliaries + 2] = v_16; + row[layout.auxiliaries + 3] = v_17; + row[layout.auxiliaries + 4] = v_18; + row[layout.auxiliaries + 5] = v_19; + row[layout.auxiliaries + 6] = v_20; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_808_0[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); + const uint64_t v_22 = seed.word(16); + row[layout.auxiliaries + 2] = v_22; + const uint64_t v_23 = seed.word(17); + row[layout.auxiliaries + 3] = v_23; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_ixvm_808(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 144 : 176; + const Seed_ixvm_808 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_ixvm_808(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_ixvm_808(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_ixvm_808<<>>(seeds, real, rows, layout, output, error); + else kernel_ixvm_808<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_ixvm_808(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 15 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 144 : encoding == 0 ? 176 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_808); +} + +extern "C" const uint8_t* aiur_trace_ixvm_contract() { + static const uint8_t hash[32] = {71, 12, 39, 10, 46, 246, 206, 207, 13, 202, 124, 148, 208, 20, 179, 9, 173, 133, 63, 124, 82, 148, 252, 238, 173, 234, 55, 16, 172, 128, 84, 141}; + return hash; +} +extern "C" const uint8_t* aiur_trace_ixvm_schema() { + static const uint8_t hash[32] = {208, 18, 254, 65, 253, 169, 165, 21, 10, 85, 41, 127, 204, 94, 105, 58, 252, 124, 16, 233, 60, 254, 66, 228, 192, 152, 34, 239, 131, 27, 144, 191}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/multi_stark.cu b/crates/aiur/cuda/generated/production/multi_stark.cu new file mode 100644 index 000000000..0c9146975 --- /dev/null +++ b/crates/aiur/cuda/generated/production/multi_stark.cu @@ -0,0 +1,6707 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +#include "trace_primitives.cuh" +static_assert(aiur_trace::ABI_VERSION == 2, "trace writer ABI mismatch"); +namespace trace_multi_stark { +using namespace aiur_trace; + +template struct Seed_multi_stark_76 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 528); + case 2: return load_u8(data + 784); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 532); + case 5: return load_u8(data + 785); + case 6: return load_u64(data + 16); + case 7: return load_u32(data + 536); + case 8: return load_u8(data + 786); + case 9: return load_u64(data + 24); + case 10: return load_u32(data + 540); + case 11: return load_u8(data + 787); + case 12: return load_u64(data + 32); + case 13: return load_u32(data + 544); + case 14: return load_u8(data + 788); + case 15: return load_u64(data + 40); + case 16: return load_u32(data + 548); + case 17: return load_u8(data + 789); + case 18: return load_u64(data + 48); + case 19: return load_u32(data + 552); + case 20: return load_u8(data + 790); + case 21: return load_u64(data + 56); + case 22: return load_u32(data + 556); + case 23: return load_u8(data + 791); + case 24: return load_u64(data + 64); + case 25: return load_u32(data + 560); + case 26: return load_u8(data + 792); + case 27: return load_u64(data + 72); + case 28: return load_u32(data + 564); + case 29: return load_u8(data + 793); + case 30: return load_u64(data + 80); + case 31: return load_u32(data + 568); + case 32: return load_u8(data + 794); + case 33: return load_u64(data + 88); + case 34: return load_u32(data + 572); + case 35: return load_u8(data + 795); + case 36: return load_u64(data + 96); + case 37: return load_u32(data + 576); + case 38: return load_u8(data + 796); + case 39: return load_u64(data + 104); + case 40: return load_u32(data + 580); + case 41: return load_u8(data + 797); + case 42: return load_u64(data + 112); + case 43: return load_u32(data + 584); + case 44: return load_u8(data + 798); + case 45: return load_u64(data + 120); + case 46: return load_u32(data + 588); + case 47: return load_u8(data + 799); + case 48: return load_u64(data + 128); + case 49: return load_u32(data + 592); + case 50: return load_u8(data + 800); + case 51: return load_u64(data + 136); + case 52: return load_u32(data + 596); + case 53: return load_u8(data + 801); + case 54: return load_u64(data + 144); + case 55: return load_u32(data + 600); + case 56: return load_u8(data + 802); + case 57: return load_u64(data + 152); + case 58: return load_u32(data + 604); + case 59: return load_u8(data + 803); + case 60: return load_u64(data + 160); + case 61: return load_u32(data + 608); + case 62: return load_u8(data + 804); + case 63: return load_u64(data + 168); + case 64: return load_u32(data + 612); + case 65: return load_u8(data + 805); + case 66: return load_u64(data + 176); + case 67: return load_u32(data + 616); + case 68: return load_u8(data + 806); + case 69: return load_u64(data + 184); + case 70: return load_u32(data + 620); + case 71: return load_u8(data + 807); + case 72: return load_u64(data + 192); + case 73: return load_u32(data + 624); + case 74: return load_u8(data + 808); + case 75: return load_u64(data + 200); + case 76: return load_u32(data + 628); + case 77: return load_u8(data + 809); + case 78: return load_u64(data + 208); + case 79: return load_u32(data + 632); + case 80: return load_u8(data + 810); + case 81: return load_u64(data + 216); + case 82: return load_u32(data + 636); + case 83: return load_u8(data + 811); + case 84: return load_u64(data + 224); + case 85: return load_u32(data + 640); + case 86: return load_u8(data + 812); + case 87: return load_u64(data + 232); + case 88: return load_u32(data + 644); + case 89: return load_u8(data + 813); + case 90: return load_u64(data + 240); + case 91: return load_u32(data + 648); + case 92: return load_u8(data + 814); + case 93: return load_u64(data + 248); + case 94: return load_u32(data + 652); + case 95: return load_u8(data + 815); + case 96: return load_u64(data + 256); + case 97: return load_u32(data + 656); + case 98: return load_u8(data + 816); + case 99: return load_u64(data + 264); + case 100: return load_u32(data + 660); + case 101: return load_u8(data + 817); + case 102: return load_u64(data + 272); + case 103: return load_u32(data + 664); + case 104: return load_u8(data + 818); + case 105: return load_u64(data + 280); + case 106: return load_u32(data + 668); + case 107: return load_u8(data + 819); + case 108: return load_u64(data + 288); + case 109: return load_u32(data + 672); + case 110: return load_u8(data + 820); + case 111: return load_u64(data + 296); + case 112: return load_u32(data + 676); + case 113: return load_u8(data + 821); + case 114: return load_u64(data + 304); + case 115: return load_u32(data + 680); + case 116: return load_u8(data + 822); + case 117: return load_u64(data + 312); + case 118: return load_u32(data + 684); + case 119: return load_u8(data + 823); + case 120: return load_u64(data + 320); + case 121: return load_u32(data + 688); + case 122: return load_u8(data + 824); + case 123: return load_u64(data + 328); + case 124: return load_u32(data + 692); + case 125: return load_u8(data + 825); + case 126: return load_u64(data + 336); + case 127: return load_u32(data + 696); + case 128: return load_u8(data + 826); + case 129: return load_u64(data + 344); + case 130: return load_u32(data + 700); + case 131: return load_u8(data + 827); + case 132: return load_u64(data + 352); + case 133: return load_u32(data + 704); + case 134: return load_u8(data + 828); + case 135: return load_u64(data + 360); + case 136: return load_u32(data + 708); + case 137: return load_u8(data + 829); + case 138: return load_u64(data + 368); + case 139: return load_u32(data + 712); + case 140: return load_u8(data + 830); + case 141: return load_u64(data + 376); + case 142: return load_u32(data + 716); + case 143: return load_u8(data + 831); + case 144: return load_u64(data + 384); + case 145: return load_u32(data + 720); + case 146: return load_u8(data + 832); + case 147: return load_u64(data + 392); + case 148: return load_u32(data + 724); + case 149: return load_u8(data + 833); + case 150: return load_u64(data + 400); + case 151: return load_u32(data + 728); + case 152: return load_u8(data + 834); + case 153: return load_u64(data + 408); + case 154: return load_u32(data + 732); + case 155: return load_u8(data + 835); + case 156: return load_u64(data + 416); + case 157: return load_u32(data + 736); + case 158: return load_u8(data + 836); + case 159: return load_u64(data + 424); + case 160: return load_u32(data + 740); + case 161: return load_u8(data + 837); + case 162: return load_u64(data + 432); + case 163: return load_u32(data + 744); + case 164: return load_u8(data + 838); + case 165: return load_u64(data + 440); + case 166: return load_u32(data + 748); + case 167: return load_u8(data + 839); + case 168: return load_u64(data + 448); + case 169: return load_u32(data + 752); + case 170: return load_u8(data + 840); + case 171: return load_u64(data + 456); + case 172: return load_u32(data + 756); + case 173: return load_u8(data + 841); + case 174: return load_u64(data + 464); + case 175: return load_u32(data + 760); + case 176: return load_u8(data + 842); + case 177: return load_u64(data + 472); + case 178: return load_u32(data + 764); + case 179: return load_u8(data + 843); + case 180: return load_u64(data + 480); + case 181: return load_u32(data + 768); + case 182: return load_u8(data + 844); + case 183: return load_u64(data + 488); + case 184: return load_u32(data + 772); + case 185: return load_u8(data + 845); + case 186: return load_u64(data + 496); + case 187: return load_u32(data + 776); + case 188: return load_u8(data + 846); + case 189: return load_u64(data + 504); + case 190: return load_u32(data + 780); + case 191: return load_u8(data + 847); + case 192: return load_u64(data + 512); + case 193: return load_u64(data + 520); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_76(Seed_multi_stark_76 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + row[layout.auxiliaries + 1] = v_1; + row[layout.auxiliaries + 2] = v_2; + row[layout.auxiliaries + 3] = v_3; + switch (v_1) { + case 0ULL: { + const uint64_t v_4 = seed.word(5); + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + row[layout.auxiliaries + 4] = v_4; + row[layout.auxiliaries + 5] = v_5; + row[layout.auxiliaries + 6] = v_6; + switch (v_4) { + case 0ULL: { + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + row[layout.auxiliaries + 7] = v_7; + row[layout.auxiliaries + 8] = v_8; + row[layout.auxiliaries + 9] = v_9; + switch (v_7) { + case 0ULL: { + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + row[layout.auxiliaries + 10] = v_10; + row[layout.auxiliaries + 11] = v_11; + row[layout.auxiliaries + 12] = v_12; + switch (v_10) { + case 0ULL: { + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + row[layout.auxiliaries + 13] = v_13; + row[layout.auxiliaries + 14] = v_14; + row[layout.auxiliaries + 15] = v_15; + switch (v_13) { + case 0ULL: { + const uint64_t v_16 = seed.word(17); + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + row[layout.auxiliaries + 16] = v_16; + row[layout.auxiliaries + 17] = v_17; + row[layout.auxiliaries + 18] = v_18; + switch (v_16) { + case 0ULL: { + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + row[layout.auxiliaries + 19] = v_19; + row[layout.auxiliaries + 20] = v_20; + row[layout.auxiliaries + 21] = v_21; + switch (v_19) { + case 0ULL: { + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 22] = v_22; + row[layout.auxiliaries + 23] = v_23; + row[layout.auxiliaries + 24] = v_24; + switch (v_22) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + row[layout.auxiliaries + 25] = v_25; + row[layout.auxiliaries + 26] = v_26; + row[layout.auxiliaries + 27] = v_27; + switch (v_25) { + case 0ULL: { + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 28] = v_28; + row[layout.auxiliaries + 29] = v_29; + row[layout.auxiliaries + 30] = v_30; + switch (v_28) { + case 0ULL: { + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + row[layout.auxiliaries + 31] = v_31; + row[layout.auxiliaries + 32] = v_32; + row[layout.auxiliaries + 33] = v_33; + switch (v_31) { + case 0ULL: { + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + row[layout.auxiliaries + 34] = v_34; + row[layout.auxiliaries + 35] = v_35; + row[layout.auxiliaries + 36] = v_36; + switch (v_34) { + case 0ULL: { + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + row[layout.auxiliaries + 37] = v_37; + row[layout.auxiliaries + 38] = v_38; + row[layout.auxiliaries + 39] = v_39; + switch (v_37) { + case 0ULL: { + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + row[layout.auxiliaries + 40] = v_40; + row[layout.auxiliaries + 41] = v_41; + row[layout.auxiliaries + 42] = v_42; + switch (v_40) { + case 0ULL: { + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + row[layout.auxiliaries + 43] = v_43; + row[layout.auxiliaries + 44] = v_44; + row[layout.auxiliaries + 45] = v_45; + switch (v_43) { + case 0ULL: { + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + row[layout.auxiliaries + 46] = v_46; + row[layout.auxiliaries + 47] = v_47; + row[layout.auxiliaries + 48] = v_48; + switch (v_46) { + case 0ULL: { + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + row[layout.auxiliaries + 49] = v_49; + row[layout.auxiliaries + 50] = v_50; + row[layout.auxiliaries + 51] = v_51; + switch (v_49) { + case 0ULL: { + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + row[layout.auxiliaries + 52] = v_52; + row[layout.auxiliaries + 53] = v_53; + row[layout.auxiliaries + 54] = v_54; + switch (v_52) { + case 0ULL: { + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + const uint64_t v_57 = seed.word(58); + row[layout.auxiliaries + 55] = v_55; + row[layout.auxiliaries + 56] = v_56; + row[layout.auxiliaries + 57] = v_57; + switch (v_55) { + case 0ULL: { + const uint64_t v_58 = seed.word(59); + const uint64_t v_59 = seed.word(60); + const uint64_t v_60 = seed.word(61); + row[layout.auxiliaries + 58] = v_58; + row[layout.auxiliaries + 59] = v_59; + row[layout.auxiliaries + 60] = v_60; + switch (v_58) { + case 0ULL: { + const uint64_t v_61 = seed.word(62); + const uint64_t v_62 = seed.word(63); + const uint64_t v_63 = seed.word(64); + row[layout.auxiliaries + 61] = v_61; + row[layout.auxiliaries + 62] = v_62; + row[layout.auxiliaries + 63] = v_63; + switch (v_61) { + case 0ULL: { + const uint64_t v_64 = seed.word(65); + const uint64_t v_65 = seed.word(66); + const uint64_t v_66 = seed.word(67); + row[layout.auxiliaries + 64] = v_64; + row[layout.auxiliaries + 65] = v_65; + row[layout.auxiliaries + 66] = v_66; + switch (v_64) { + case 0ULL: { + const uint64_t v_67 = seed.word(68); + const uint64_t v_68 = seed.word(69); + const uint64_t v_69 = seed.word(70); + row[layout.auxiliaries + 67] = v_67; + row[layout.auxiliaries + 68] = v_68; + row[layout.auxiliaries + 69] = v_69; + switch (v_67) { + case 0ULL: { + const uint64_t v_70 = seed.word(71); + const uint64_t v_71 = seed.word(72); + const uint64_t v_72 = seed.word(73); + row[layout.auxiliaries + 70] = v_70; + row[layout.auxiliaries + 71] = v_71; + row[layout.auxiliaries + 72] = v_72; + switch (v_70) { + case 0ULL: { + const uint64_t v_73 = seed.word(74); + const uint64_t v_74 = seed.word(75); + const uint64_t v_75 = seed.word(76); + row[layout.auxiliaries + 73] = v_73; + row[layout.auxiliaries + 74] = v_74; + row[layout.auxiliaries + 75] = v_75; + switch (v_73) { + case 0ULL: { + const uint64_t v_76 = seed.word(77); + const uint64_t v_77 = seed.word(78); + const uint64_t v_78 = seed.word(79); + row[layout.auxiliaries + 76] = v_76; + row[layout.auxiliaries + 77] = v_77; + row[layout.auxiliaries + 78] = v_78; + switch (v_76) { + case 0ULL: { + const uint64_t v_79 = seed.word(80); + const uint64_t v_80 = seed.word(81); + const uint64_t v_81 = seed.word(82); + row[layout.auxiliaries + 79] = v_79; + row[layout.auxiliaries + 80] = v_80; + row[layout.auxiliaries + 81] = v_81; + switch (v_79) { + case 0ULL: { + const uint64_t v_82 = seed.word(83); + const uint64_t v_83 = seed.word(84); + const uint64_t v_84 = seed.word(85); + row[layout.auxiliaries + 82] = v_82; + row[layout.auxiliaries + 83] = v_83; + row[layout.auxiliaries + 84] = v_84; + switch (v_82) { + case 0ULL: { + const uint64_t v_85 = seed.word(86); + const uint64_t v_86 = seed.word(87); + const uint64_t v_87 = seed.word(88); + row[layout.auxiliaries + 85] = v_85; + row[layout.auxiliaries + 86] = v_86; + row[layout.auxiliaries + 87] = v_87; + switch (v_85) { + case 0ULL: { + const uint64_t v_88 = seed.word(89); + const uint64_t v_89 = seed.word(90); + const uint64_t v_90 = seed.word(91); + row[layout.auxiliaries + 88] = v_88; + row[layout.auxiliaries + 89] = v_89; + row[layout.auxiliaries + 90] = v_90; + switch (v_88) { + case 0ULL: { + const uint64_t v_91 = seed.word(92); + const uint64_t v_92 = seed.word(93); + const uint64_t v_93 = seed.word(94); + row[layout.auxiliaries + 91] = v_91; + row[layout.auxiliaries + 92] = v_92; + row[layout.auxiliaries + 93] = v_93; + switch (v_91) { + case 0ULL: { + const uint64_t v_94 = seed.word(95); + const uint64_t v_95 = seed.word(96); + const uint64_t v_96 = seed.word(97); + row[layout.auxiliaries + 94] = v_94; + row[layout.auxiliaries + 95] = v_95; + row[layout.auxiliaries + 96] = v_96; + switch (v_94) { + case 0ULL: { + const uint64_t v_97 = seed.word(98); + const uint64_t v_98 = seed.word(99); + const uint64_t v_99 = seed.word(100); + row[layout.auxiliaries + 97] = v_97; + row[layout.auxiliaries + 98] = v_98; + row[layout.auxiliaries + 99] = v_99; + switch (v_97) { + case 0ULL: { + const uint64_t v_100 = seed.word(101); + const uint64_t v_101 = seed.word(102); + const uint64_t v_102 = seed.word(103); + row[layout.auxiliaries + 100] = v_100; + row[layout.auxiliaries + 101] = v_101; + row[layout.auxiliaries + 102] = v_102; + switch (v_100) { + case 0ULL: { + const uint64_t v_103 = seed.word(104); + const uint64_t v_104 = seed.word(105); + const uint64_t v_105 = seed.word(106); + row[layout.auxiliaries + 103] = v_103; + row[layout.auxiliaries + 104] = v_104; + row[layout.auxiliaries + 105] = v_105; + switch (v_103) { + case 0ULL: { + const uint64_t v_106 = seed.word(107); + const uint64_t v_107 = seed.word(108); + const uint64_t v_108 = seed.word(109); + row[layout.auxiliaries + 106] = v_106; + row[layout.auxiliaries + 107] = v_107; + row[layout.auxiliaries + 108] = v_108; + switch (v_106) { + case 0ULL: { + const uint64_t v_109 = seed.word(110); + const uint64_t v_110 = seed.word(111); + const uint64_t v_111 = seed.word(112); + row[layout.auxiliaries + 109] = v_109; + row[layout.auxiliaries + 110] = v_110; + row[layout.auxiliaries + 111] = v_111; + switch (v_109) { + case 0ULL: { + const uint64_t v_112 = seed.word(113); + const uint64_t v_113 = seed.word(114); + const uint64_t v_114 = seed.word(115); + row[layout.auxiliaries + 112] = v_112; + row[layout.auxiliaries + 113] = v_113; + row[layout.auxiliaries + 114] = v_114; + switch (v_112) { + case 0ULL: { + const uint64_t v_115 = seed.word(116); + const uint64_t v_116 = seed.word(117); + const uint64_t v_117 = seed.word(118); + row[layout.auxiliaries + 115] = v_115; + row[layout.auxiliaries + 116] = v_116; + row[layout.auxiliaries + 117] = v_117; + switch (v_115) { + case 0ULL: { + const uint64_t v_118 = seed.word(119); + const uint64_t v_119 = seed.word(120); + const uint64_t v_120 = seed.word(121); + row[layout.auxiliaries + 118] = v_118; + row[layout.auxiliaries + 119] = v_119; + row[layout.auxiliaries + 120] = v_120; + switch (v_118) { + case 0ULL: { + const uint64_t v_121 = seed.word(122); + const uint64_t v_122 = seed.word(123); + const uint64_t v_123 = seed.word(124); + row[layout.auxiliaries + 121] = v_121; + row[layout.auxiliaries + 122] = v_122; + row[layout.auxiliaries + 123] = v_123; + switch (v_121) { + case 0ULL: { + const uint64_t v_124 = seed.word(125); + const uint64_t v_125 = seed.word(126); + const uint64_t v_126 = seed.word(127); + row[layout.auxiliaries + 124] = v_124; + row[layout.auxiliaries + 125] = v_125; + row[layout.auxiliaries + 126] = v_126; + switch (v_124) { + case 0ULL: { + const uint64_t v_127 = seed.word(128); + const uint64_t v_128 = seed.word(129); + const uint64_t v_129 = seed.word(130); + row[layout.auxiliaries + 127] = v_127; + row[layout.auxiliaries + 128] = v_128; + row[layout.auxiliaries + 129] = v_129; + switch (v_127) { + case 0ULL: { + const uint64_t v_130 = seed.word(131); + const uint64_t v_131 = seed.word(132); + const uint64_t v_132 = seed.word(133); + row[layout.auxiliaries + 130] = v_130; + row[layout.auxiliaries + 131] = v_131; + row[layout.auxiliaries + 132] = v_132; + switch (v_130) { + case 0ULL: { + const uint64_t v_133 = seed.word(134); + const uint64_t v_134 = seed.word(135); + const uint64_t v_135 = seed.word(136); + row[layout.auxiliaries + 133] = v_133; + row[layout.auxiliaries + 134] = v_134; + row[layout.auxiliaries + 135] = v_135; + switch (v_133) { + case 0ULL: { + const uint64_t v_136 = seed.word(137); + const uint64_t v_137 = seed.word(138); + const uint64_t v_138 = seed.word(139); + row[layout.auxiliaries + 136] = v_136; + row[layout.auxiliaries + 137] = v_137; + row[layout.auxiliaries + 138] = v_138; + switch (v_136) { + case 0ULL: { + const uint64_t v_139 = seed.word(140); + const uint64_t v_140 = seed.word(141); + const uint64_t v_141 = seed.word(142); + row[layout.auxiliaries + 139] = v_139; + row[layout.auxiliaries + 140] = v_140; + row[layout.auxiliaries + 141] = v_141; + switch (v_139) { + case 0ULL: { + const uint64_t v_142 = seed.word(143); + const uint64_t v_143 = seed.word(144); + const uint64_t v_144 = seed.word(145); + row[layout.auxiliaries + 142] = v_142; + row[layout.auxiliaries + 143] = v_143; + row[layout.auxiliaries + 144] = v_144; + switch (v_142) { + case 0ULL: { + const uint64_t v_145 = seed.word(146); + const uint64_t v_146 = seed.word(147); + const uint64_t v_147 = seed.word(148); + row[layout.auxiliaries + 145] = v_145; + row[layout.auxiliaries + 146] = v_146; + row[layout.auxiliaries + 147] = v_147; + switch (v_145) { + case 0ULL: { + const uint64_t v_148 = seed.word(149); + const uint64_t v_149 = seed.word(150); + const uint64_t v_150 = seed.word(151); + row[layout.auxiliaries + 148] = v_148; + row[layout.auxiliaries + 149] = v_149; + row[layout.auxiliaries + 150] = v_150; + switch (v_148) { + case 0ULL: { + const uint64_t v_151 = seed.word(152); + const uint64_t v_152 = seed.word(153); + const uint64_t v_153 = seed.word(154); + row[layout.auxiliaries + 151] = v_151; + row[layout.auxiliaries + 152] = v_152; + row[layout.auxiliaries + 153] = v_153; + switch (v_151) { + case 0ULL: { + const uint64_t v_154 = seed.word(155); + const uint64_t v_155 = seed.word(156); + const uint64_t v_156 = seed.word(157); + row[layout.auxiliaries + 154] = v_154; + row[layout.auxiliaries + 155] = v_155; + row[layout.auxiliaries + 156] = v_156; + switch (v_154) { + case 0ULL: { + const uint64_t v_157 = seed.word(158); + const uint64_t v_158 = seed.word(159); + const uint64_t v_159 = seed.word(160); + row[layout.auxiliaries + 157] = v_157; + row[layout.auxiliaries + 158] = v_158; + row[layout.auxiliaries + 159] = v_159; + switch (v_157) { + case 0ULL: { + const uint64_t v_160 = seed.word(161); + const uint64_t v_161 = seed.word(162); + const uint64_t v_162 = seed.word(163); + row[layout.auxiliaries + 160] = v_160; + row[layout.auxiliaries + 161] = v_161; + row[layout.auxiliaries + 162] = v_162; + switch (v_160) { + case 0ULL: { + const uint64_t v_163 = seed.word(164); + const uint64_t v_164 = seed.word(165); + const uint64_t v_165 = seed.word(166); + row[layout.auxiliaries + 163] = v_163; + row[layout.auxiliaries + 164] = v_164; + row[layout.auxiliaries + 165] = v_165; + switch (v_163) { + case 0ULL: { + const uint64_t v_166 = seed.word(167); + const uint64_t v_167 = seed.word(168); + const uint64_t v_168 = seed.word(169); + row[layout.auxiliaries + 166] = v_166; + row[layout.auxiliaries + 167] = v_167; + row[layout.auxiliaries + 168] = v_168; + switch (v_166) { + case 0ULL: { + const uint64_t v_169 = seed.word(170); + const uint64_t v_170 = seed.word(171); + const uint64_t v_171 = seed.word(172); + row[layout.auxiliaries + 169] = v_169; + row[layout.auxiliaries + 170] = v_170; + row[layout.auxiliaries + 171] = v_171; + switch (v_169) { + case 0ULL: { + const uint64_t v_172 = seed.word(173); + const uint64_t v_173 = seed.word(174); + const uint64_t v_174 = seed.word(175); + row[layout.auxiliaries + 172] = v_172; + row[layout.auxiliaries + 173] = v_173; + row[layout.auxiliaries + 174] = v_174; + switch (v_172) { + case 0ULL: { + const uint64_t v_175 = seed.word(176); + const uint64_t v_176 = seed.word(177); + const uint64_t v_177 = seed.word(178); + row[layout.auxiliaries + 175] = v_175; + row[layout.auxiliaries + 176] = v_176; + row[layout.auxiliaries + 177] = v_177; + switch (v_175) { + case 0ULL: { + const uint64_t v_178 = seed.word(179); + const uint64_t v_179 = seed.word(180); + const uint64_t v_180 = seed.word(181); + row[layout.auxiliaries + 178] = v_178; + row[layout.auxiliaries + 179] = v_179; + row[layout.auxiliaries + 180] = v_180; + switch (v_178) { + case 0ULL: { + const uint64_t v_181 = seed.word(182); + const uint64_t v_182 = seed.word(183); + const uint64_t v_183 = seed.word(184); + row[layout.auxiliaries + 181] = v_181; + row[layout.auxiliaries + 182] = v_182; + row[layout.auxiliaries + 183] = v_183; + switch (v_181) { + case 0ULL: { + const uint64_t v_184 = seed.word(185); + const uint64_t v_185 = seed.word(186); + const uint64_t v_186 = seed.word(187); + row[layout.auxiliaries + 184] = v_184; + row[layout.auxiliaries + 185] = v_185; + row[layout.auxiliaries + 186] = v_186; + switch (v_184) { + case 0ULL: { + const uint64_t v_187 = seed.word(188); + const uint64_t v_188 = seed.word(189); + const uint64_t v_189 = seed.word(190); + row[layout.auxiliaries + 187] = v_187; + row[layout.auxiliaries + 188] = v_188; + row[layout.auxiliaries + 189] = v_189; + switch (v_187) { + case 0ULL: { + const uint64_t v_190 = seed.word(191); + const uint64_t v_191 = seed.word(192); + const uint64_t v_192 = seed.word(193); + row[layout.auxiliaries + 190] = v_190; + row[layout.auxiliaries + 191] = v_191; + row[layout.auxiliaries + 192] = v_192; + switch (v_190) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_76(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 848 : 1552; + const Seed_multi_stark_76 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_76(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_76(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_76<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_76<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_76(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 1 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 193) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 848 : encoding == 0 ? 1552 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_76); +} + +__device__ __constant__ uint64_t inverse_78_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_3[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_4[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_5[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_6[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_7[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_8[] = {0ULL}; +__device__ __constant__ uint64_t inverse_78_9[] = {0ULL}; +template struct Seed_multi_stark_78 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 308); + case 3: return load_u64(data + 16); + case 4: return load_u32(data + 288); + case 5: return load_u32(data + 292); + case 6: return load_u64(data + 24); + case 7: return load_u64(data + 32); + case 8: return load_u64(data + 40); + case 9: return load_u64(data + 48); + case 10: return load_u64(data + 56); + case 11: return load_u64(data + 64); + case 12: return load_u64(data + 72); + case 13: return load_u64(data + 80); + case 14: return load_u64(data + 88); + case 15: return load_u64(data + 96); + case 16: return load_u64(data + 104); + case 17: return load_u64(data + 112); + case 18: return load_u64(data + 120); + case 19: return load_u64(data + 128); + case 20: return load_u64(data + 136); + case 21: return load_u64(data + 144); + case 22: return load_u64(data + 152); + case 23: return load_u64(data + 160); + case 24: return load_u64(data + 168); + case 25: return load_u64(data + 176); + case 26: return load_u64(data + 184); + case 27: return load_u64(data + 192); + case 28: return load_u64(data + 200); + case 29: return load_u64(data + 208); + case 30: return load_u64(data + 216); + case 31: return load_u64(data + 224); + case 32: return load_u64(data + 232); + case 33: return load_u64(data + 240); + case 34: return load_u64(data + 248); + case 35: return load_u64(data + 256); + case 36: return load_u64(data + 264); + case 37: return load_u64(data + 272); + case 38: return load_u64(data + 280); + case 39: return load_u32(data + 296); + case 40: return load_u8(data + 309); + case 41: return load_u8(data + 310); + case 42: return load_u8(data + 311); + case 43: return load_u8(data + 312); + case 44: return load_u8(data + 313); + case 45: return load_u8(data + 314); + case 46: return load_u8(data + 315); + case 47: return load_u8(data + 316); + case 48: return load_u8(data + 317); + case 49: return load_u8(data + 318); + case 50: return load_u8(data + 319); + case 51: return load_u8(data + 320); + case 52: return load_u8(data + 321); + case 53: return load_u8(data + 322); + case 54: return load_u8(data + 323); + case 55: return load_u8(data + 324); + case 56: return load_u8(data + 325); + case 57: return load_u8(data + 326); + case 58: return load_u8(data + 327); + case 59: return load_u8(data + 328); + case 60: return load_u8(data + 329); + case 61: return load_u8(data + 330); + case 62: return load_u8(data + 331); + case 63: return load_u8(data + 332); + case 64: return load_u8(data + 333); + case 65: return load_u8(data + 334); + case 66: return load_u8(data + 335); + case 67: return load_u8(data + 336); + case 68: return load_u8(data + 337); + case 69: return load_u8(data + 338); + case 70: return load_u8(data + 339); + case 71: return load_u8(data + 340); + case 72: return load_u8(data + 341); + case 73: return load_u8(data + 342); + case 74: return load_u8(data + 343); + case 75: return load_u8(data + 344); + case 76: return load_u8(data + 345); + case 77: return load_u8(data + 346); + case 78: return load_u8(data + 347); + case 79: return load_u8(data + 348); + case 80: return load_u8(data + 349); + case 81: return load_u8(data + 350); + case 82: return load_u8(data + 351); + case 83: return load_u8(data + 352); + case 84: return load_u8(data + 353); + case 85: return load_u8(data + 354); + case 86: return load_u8(data + 355); + case 87: return load_u32(data + 300); + case 88: return load_u8(data + 356); + case 89: return load_u8(data + 357); + case 90: return load_u8(data + 358); + case 91: return load_u8(data + 359); + case 92: return load_u8(data + 360); + case 93: return load_u8(data + 361); + case 94: return load_u8(data + 362); + case 95: return load_u8(data + 363); + case 96: return load_u8(data + 364); + case 97: return load_u8(data + 365); + case 98: return load_u8(data + 366); + case 99: return load_u8(data + 367); + case 100: return load_u8(data + 368); + case 101: return load_u8(data + 369); + case 102: return load_u8(data + 370); + case 103: return load_u8(data + 371); + case 104: return load_u8(data + 372); + case 105: return load_u8(data + 373); + case 106: return load_u8(data + 374); + case 107: return load_u8(data + 375); + case 108: return load_u8(data + 376); + case 109: return load_u8(data + 377); + case 110: return load_u8(data + 378); + case 111: return load_u8(data + 379); + case 112: return load_u8(data + 380); + case 113: return load_u8(data + 381); + case 114: return load_u8(data + 382); + case 115: return load_u8(data + 383); + case 116: return load_u8(data + 384); + case 117: return load_u8(data + 385); + case 118: return load_u8(data + 386); + case 119: return load_u8(data + 387); + case 120: return load_u8(data + 388); + case 121: return load_u8(data + 389); + case 122: return load_u8(data + 390); + case 123: return load_u8(data + 391); + case 124: return load_u8(data + 392); + case 125: return load_u8(data + 393); + case 126: return load_u8(data + 394); + case 127: return load_u8(data + 395); + case 128: return load_u8(data + 396); + case 129: return load_u8(data + 397); + case 130: return load_u8(data + 398); + case 131: return load_u8(data + 399); + case 132: return load_u8(data + 400); + case 133: return load_u8(data + 401); + case 134: return load_u8(data + 402); + case 135: return load_u8(data + 403); + case 136: return load_u8(data + 404); + case 137: return load_u8(data + 405); + case 138: return load_u8(data + 406); + case 139: return load_u8(data + 407); + case 140: return load_u8(data + 408); + case 141: return load_u8(data + 409); + case 142: return load_u8(data + 410); + case 143: return load_u8(data + 411); + case 144: return load_u8(data + 412); + case 145: return load_u32(data + 304); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_78(Seed_multi_stark_78 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + switch (v_1) { + case 0ULL: { + switch (v_2) { + case 0ULL: { + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + switch (v_9) { + case 0ULL: { + switch (v_10) { + case 0ULL: { + switch (v_11) { + case 0ULL: { + switch (v_12) { + case 0ULL: { + switch (v_13) { + case 0ULL: { + switch (v_14) { + case 0ULL: { + switch (v_15) { + case 0ULL: { + switch (v_16) { + case 0ULL: { + const uint64_t v_19 = seed.word(15); + const uint64_t v_20 = seed.word(16); + const uint64_t v_21 = seed.word(17); + const uint64_t v_22 = seed.word(18); + const uint64_t v_23 = seed.word(19); + const uint64_t v_24 = seed.word(20); + const uint64_t v_25 = seed.word(21); + const uint64_t v_26 = seed.word(22); + const uint64_t v_27 = seed.word(23); + const uint64_t v_28 = seed.word(24); + const uint64_t v_29 = seed.word(25); + const uint64_t v_30 = seed.word(26); + const uint64_t v_31 = seed.word(27); + const uint64_t v_32 = seed.word(28); + const uint64_t v_33 = seed.word(29); + const uint64_t v_34 = seed.word(30); + const uint64_t v_35 = seed.word(31); + const uint64_t v_36 = seed.word(32); + const uint64_t v_37 = seed.word(33); + const uint64_t v_38 = seed.word(34); + const uint64_t v_39 = seed.word(35); + const uint64_t v_40 = seed.word(36); + const uint64_t v_41 = seed.word(37); + const uint64_t v_42 = seed.word(38); + const uint64_t v_43 = seed.word(39); + const uint64_t v_44 = seed.word(40); + const uint64_t v_45 = seed.word(41); + const uint64_t v_46 = seed.word(42); + const uint64_t v_47 = seed.word(43); + const uint64_t v_48 = seed.word(44); + const uint64_t v_49 = seed.word(45); + const uint64_t v_50 = seed.word(46); + row[layout.auxiliaries + 9] = v_19; + row[layout.auxiliaries + 10] = v_20; + row[layout.auxiliaries + 11] = v_21; + row[layout.auxiliaries + 12] = v_22; + row[layout.auxiliaries + 13] = v_23; + row[layout.auxiliaries + 14] = v_24; + row[layout.auxiliaries + 15] = v_25; + row[layout.auxiliaries + 16] = v_26; + row[layout.auxiliaries + 17] = v_27; + row[layout.auxiliaries + 18] = v_28; + row[layout.auxiliaries + 19] = v_29; + row[layout.auxiliaries + 20] = v_30; + row[layout.auxiliaries + 21] = v_31; + row[layout.auxiliaries + 22] = v_32; + row[layout.auxiliaries + 23] = v_33; + row[layout.auxiliaries + 24] = v_34; + row[layout.auxiliaries + 25] = v_35; + row[layout.auxiliaries + 26] = v_36; + row[layout.auxiliaries + 27] = v_37; + row[layout.auxiliaries + 28] = v_38; + row[layout.auxiliaries + 29] = v_39; + row[layout.auxiliaries + 30] = v_40; + row[layout.auxiliaries + 31] = v_41; + row[layout.auxiliaries + 32] = v_42; + row[layout.auxiliaries + 33] = v_43; + row[layout.auxiliaries + 34] = v_44; + row[layout.auxiliaries + 35] = v_45; + row[layout.auxiliaries + 36] = v_46; + row[layout.auxiliaries + 37] = v_47; + row[layout.auxiliaries + 38] = v_48; + row[layout.auxiliaries + 39] = v_49; + row[layout.auxiliaries + 40] = v_50; + const uint64_t v_52 = seed.word(47); + const uint64_t v_53 = seed.word(48); + const uint64_t v_54 = seed.word(49); + const uint64_t v_55 = seed.word(50); + const uint64_t v_56 = seed.word(51); + const uint64_t v_57 = seed.word(52); + const uint64_t v_58 = seed.word(53); + const uint64_t v_59 = seed.word(54); + row[layout.auxiliaries + 41] = v_52; + row[layout.auxiliaries + 42] = v_53; + row[layout.auxiliaries + 43] = v_54; + row[layout.auxiliaries + 44] = v_55; + row[layout.auxiliaries + 45] = v_56; + row[layout.auxiliaries + 46] = v_57; + row[layout.auxiliaries + 47] = v_58; + row[layout.auxiliaries + 48] = v_59; + const uint64_t v_75 = seed.word(55); + const uint64_t v_76 = seed.word(56); + const uint64_t v_77 = seed.word(57); + const uint64_t v_78 = seed.word(58); + const uint64_t v_79 = seed.word(59); + const uint64_t v_80 = seed.word(60); + const uint64_t v_81 = seed.word(61); + const uint64_t v_82 = seed.word(62); + const uint64_t v_83 = seed.word(63); + const uint64_t v_84 = seed.word(64); + const uint64_t v_85 = seed.word(65); + const uint64_t v_86 = seed.word(66); + const uint64_t v_87 = seed.word(67); + const uint64_t v_88 = seed.word(68); + const uint64_t v_89 = seed.word(69); + const uint64_t v_90 = seed.word(70); + const uint64_t v_91 = seed.word(71); + const uint64_t v_92 = seed.word(72); + const uint64_t v_93 = seed.word(73); + const uint64_t v_94 = seed.word(74); + const uint64_t v_95 = seed.word(75); + const uint64_t v_96 = seed.word(76); + const uint64_t v_97 = seed.word(77); + const uint64_t v_98 = seed.word(78); + const uint64_t v_99 = seed.word(79); + const uint64_t v_100 = seed.word(80); + const uint64_t v_101 = seed.word(81); + const uint64_t v_102 = seed.word(82); + const uint64_t v_103 = seed.word(83); + const uint64_t v_104 = seed.word(84); + const uint64_t v_105 = seed.word(85); + const uint64_t v_106 = seed.word(86); + row[layout.auxiliaries + 49] = v_75; + row[layout.auxiliaries + 50] = v_76; + row[layout.auxiliaries + 51] = v_77; + row[layout.auxiliaries + 52] = v_78; + row[layout.auxiliaries + 53] = v_79; + row[layout.auxiliaries + 54] = v_80; + row[layout.auxiliaries + 55] = v_81; + row[layout.auxiliaries + 56] = v_82; + row[layout.auxiliaries + 57] = v_83; + row[layout.auxiliaries + 58] = v_84; + row[layout.auxiliaries + 59] = v_85; + row[layout.auxiliaries + 60] = v_86; + row[layout.auxiliaries + 61] = v_87; + row[layout.auxiliaries + 62] = v_88; + row[layout.auxiliaries + 63] = v_89; + row[layout.auxiliaries + 64] = v_90; + row[layout.auxiliaries + 65] = v_91; + row[layout.auxiliaries + 66] = v_92; + row[layout.auxiliaries + 67] = v_93; + row[layout.auxiliaries + 68] = v_94; + row[layout.auxiliaries + 69] = v_95; + row[layout.auxiliaries + 70] = v_96; + row[layout.auxiliaries + 71] = v_97; + row[layout.auxiliaries + 72] = v_98; + row[layout.auxiliaries + 73] = v_99; + row[layout.auxiliaries + 74] = v_100; + row[layout.auxiliaries + 75] = v_101; + row[layout.auxiliaries + 76] = v_102; + row[layout.auxiliaries + 77] = v_103; + row[layout.auxiliaries + 78] = v_104; + row[layout.auxiliaries + 79] = v_105; + row[layout.auxiliaries + 80] = v_106; + const uint64_t v_107 = seed.word(87); + row[layout.auxiliaries + 81] = v_107; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 9] = (v_16 <= 0ULL ? inverse_78_0[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_15 <= 0ULL ? inverse_78_1[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_14 <= 0ULL ? inverse_78_2[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_13 <= 0ULL ? inverse_78_3[v_13] : inverse(goldilocks_sub(v_13, 0ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_12 <= 0ULL ? inverse_78_4[v_12] : inverse(goldilocks_sub(v_12, 0ULL))); + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_11 <= 0ULL ? inverse_78_5[v_11] : inverse(goldilocks_sub(v_11, 0ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_10 <= 0ULL ? inverse_78_6[v_10] : inverse(goldilocks_sub(v_10, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 9] = (v_9 <= 0ULL ? inverse_78_7[v_9] : inverse(goldilocks_sub(v_9, 0ULL))); + row[layout.selectors + 8] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_2 <= 0ULL ? inverse_78_8[v_2] : inverse(goldilocks_sub(v_2, 0ULL))); + const uint64_t v_109 = seed.word(7); + const uint64_t v_110 = seed.word(8); + const uint64_t v_111 = seed.word(9); + const uint64_t v_112 = seed.word(10); + const uint64_t v_113 = seed.word(11); + const uint64_t v_114 = seed.word(12); + const uint64_t v_115 = seed.word(13); + const uint64_t v_116 = seed.word(14); + const uint64_t v_117 = seed.word(15); + const uint64_t v_118 = seed.word(16); + const uint64_t v_119 = seed.word(17); + const uint64_t v_120 = seed.word(18); + const uint64_t v_121 = seed.word(19); + const uint64_t v_122 = seed.word(20); + const uint64_t v_123 = seed.word(21); + const uint64_t v_124 = seed.word(22); + const uint64_t v_125 = seed.word(23); + const uint64_t v_126 = seed.word(24); + const uint64_t v_127 = seed.word(25); + const uint64_t v_128 = seed.word(26); + const uint64_t v_129 = seed.word(27); + const uint64_t v_130 = seed.word(28); + const uint64_t v_131 = seed.word(29); + const uint64_t v_132 = seed.word(30); + const uint64_t v_133 = seed.word(31); + const uint64_t v_134 = seed.word(32); + const uint64_t v_135 = seed.word(33); + const uint64_t v_136 = seed.word(34); + const uint64_t v_137 = seed.word(35); + const uint64_t v_138 = seed.word(36); + const uint64_t v_139 = seed.word(37); + const uint64_t v_140 = seed.word(38); + row[layout.auxiliaries + 2] = v_109; + row[layout.auxiliaries + 3] = v_110; + row[layout.auxiliaries + 4] = v_111; + row[layout.auxiliaries + 5] = v_112; + row[layout.auxiliaries + 6] = v_113; + row[layout.auxiliaries + 7] = v_114; + row[layout.auxiliaries + 8] = v_115; + row[layout.auxiliaries + 9] = v_116; + row[layout.auxiliaries + 10] = v_117; + row[layout.auxiliaries + 11] = v_118; + row[layout.auxiliaries + 12] = v_119; + row[layout.auxiliaries + 13] = v_120; + row[layout.auxiliaries + 14] = v_121; + row[layout.auxiliaries + 15] = v_122; + row[layout.auxiliaries + 16] = v_123; + row[layout.auxiliaries + 17] = v_124; + row[layout.auxiliaries + 18] = v_125; + row[layout.auxiliaries + 19] = v_126; + row[layout.auxiliaries + 20] = v_127; + row[layout.auxiliaries + 21] = v_128; + row[layout.auxiliaries + 22] = v_129; + row[layout.auxiliaries + 23] = v_130; + row[layout.auxiliaries + 24] = v_131; + row[layout.auxiliaries + 25] = v_132; + row[layout.auxiliaries + 26] = v_133; + row[layout.auxiliaries + 27] = v_134; + row[layout.auxiliaries + 28] = v_135; + row[layout.auxiliaries + 29] = v_136; + row[layout.auxiliaries + 30] = v_137; + row[layout.auxiliaries + 31] = v_138; + row[layout.auxiliaries + 32] = v_139; + row[layout.auxiliaries + 33] = v_140; + const uint64_t v_141 = seed.word(39); + row[layout.auxiliaries + 34] = v_141; + row[layout.selectors + 9] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_78_9[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_142 = seed.word(7); + const uint64_t v_143 = seed.word(8); + const uint64_t v_144 = seed.word(9); + const uint64_t v_145 = seed.word(10); + const uint64_t v_146 = seed.word(11); + const uint64_t v_147 = seed.word(12); + const uint64_t v_148 = seed.word(13); + const uint64_t v_149 = seed.word(14); + row[layout.auxiliaries + 2] = v_142; + row[layout.auxiliaries + 3] = v_143; + row[layout.auxiliaries + 4] = v_144; + row[layout.auxiliaries + 5] = v_145; + row[layout.auxiliaries + 6] = v_146; + row[layout.auxiliaries + 7] = v_147; + row[layout.auxiliaries + 8] = v_148; + row[layout.auxiliaries + 9] = v_149; + const uint64_t v_150 = seed.word(15); + row[layout.auxiliaries + 10] = v_150; + const uint64_t v_152 = goldilocks_sub(v_2, v_1); + const uint64_t v_153 = uint64_t(v_152 == 0); + row[layout.auxiliaries + 11] = inverse(v_152); + row[layout.auxiliaries + 12] = v_153; + const uint64_t v_159 = seed.word(16); + row[layout.auxiliaries + 13] = v_159; + const uint64_t v_160 = seed.word(17); + const uint64_t v_161 = seed.word(18); + const uint64_t v_162 = seed.word(19); + const uint64_t v_163 = seed.word(20); + const uint64_t v_164 = seed.word(21); + const uint64_t v_165 = seed.word(22); + const uint64_t v_166 = seed.word(23); + const uint64_t v_167 = seed.word(24); + const uint64_t v_168 = seed.word(25); + const uint64_t v_169 = seed.word(26); + const uint64_t v_170 = seed.word(27); + const uint64_t v_171 = seed.word(28); + const uint64_t v_172 = seed.word(29); + const uint64_t v_173 = seed.word(30); + const uint64_t v_174 = seed.word(31); + const uint64_t v_175 = seed.word(32); + const uint64_t v_176 = seed.word(33); + const uint64_t v_177 = seed.word(34); + const uint64_t v_178 = seed.word(35); + const uint64_t v_179 = seed.word(36); + const uint64_t v_180 = seed.word(37); + const uint64_t v_181 = seed.word(38); + const uint64_t v_182 = seed.word(39); + const uint64_t v_183 = seed.word(40); + const uint64_t v_184 = seed.word(41); + const uint64_t v_185 = seed.word(42); + const uint64_t v_186 = seed.word(43); + const uint64_t v_187 = seed.word(44); + const uint64_t v_188 = seed.word(45); + const uint64_t v_189 = seed.word(46); + const uint64_t v_190 = seed.word(47); + const uint64_t v_191 = seed.word(48); + const uint64_t v_192 = seed.word(49); + const uint64_t v_193 = seed.word(50); + const uint64_t v_194 = seed.word(51); + const uint64_t v_195 = seed.word(52); + const uint64_t v_196 = seed.word(53); + const uint64_t v_197 = seed.word(54); + const uint64_t v_198 = seed.word(55); + const uint64_t v_199 = seed.word(56); + const uint64_t v_200 = seed.word(57); + const uint64_t v_201 = seed.word(58); + const uint64_t v_202 = seed.word(59); + const uint64_t v_203 = seed.word(60); + const uint64_t v_204 = seed.word(61); + const uint64_t v_205 = seed.word(62); + const uint64_t v_206 = seed.word(63); + const uint64_t v_207 = seed.word(64); + const uint64_t v_208 = seed.word(65); + const uint64_t v_209 = seed.word(66); + const uint64_t v_210 = seed.word(67); + const uint64_t v_211 = seed.word(68); + const uint64_t v_212 = seed.word(69); + const uint64_t v_213 = seed.word(70); + const uint64_t v_214 = seed.word(71); + const uint64_t v_215 = seed.word(72); + const uint64_t v_216 = seed.word(73); + const uint64_t v_217 = seed.word(74); + const uint64_t v_218 = seed.word(75); + const uint64_t v_219 = seed.word(76); + const uint64_t v_220 = seed.word(77); + const uint64_t v_221 = seed.word(78); + const uint64_t v_222 = seed.word(79); + const uint64_t v_223 = seed.word(80); + row[layout.auxiliaries + 14] = v_160; + row[layout.auxiliaries + 15] = v_161; + row[layout.auxiliaries + 16] = v_162; + row[layout.auxiliaries + 17] = v_163; + row[layout.auxiliaries + 18] = v_164; + row[layout.auxiliaries + 19] = v_165; + row[layout.auxiliaries + 20] = v_166; + row[layout.auxiliaries + 21] = v_167; + row[layout.auxiliaries + 22] = v_168; + row[layout.auxiliaries + 23] = v_169; + row[layout.auxiliaries + 24] = v_170; + row[layout.auxiliaries + 25] = v_171; + row[layout.auxiliaries + 26] = v_172; + row[layout.auxiliaries + 27] = v_173; + row[layout.auxiliaries + 28] = v_174; + row[layout.auxiliaries + 29] = v_175; + row[layout.auxiliaries + 30] = v_176; + row[layout.auxiliaries + 31] = v_177; + row[layout.auxiliaries + 32] = v_178; + row[layout.auxiliaries + 33] = v_179; + row[layout.auxiliaries + 34] = v_180; + row[layout.auxiliaries + 35] = v_181; + row[layout.auxiliaries + 36] = v_182; + row[layout.auxiliaries + 37] = v_183; + row[layout.auxiliaries + 38] = v_184; + row[layout.auxiliaries + 39] = v_185; + row[layout.auxiliaries + 40] = v_186; + row[layout.auxiliaries + 41] = v_187; + row[layout.auxiliaries + 42] = v_188; + row[layout.auxiliaries + 43] = v_189; + row[layout.auxiliaries + 44] = v_190; + row[layout.auxiliaries + 45] = v_191; + row[layout.auxiliaries + 46] = v_192; + row[layout.auxiliaries + 47] = v_193; + row[layout.auxiliaries + 48] = v_194; + row[layout.auxiliaries + 49] = v_195; + row[layout.auxiliaries + 50] = v_196; + row[layout.auxiliaries + 51] = v_197; + row[layout.auxiliaries + 52] = v_198; + row[layout.auxiliaries + 53] = v_199; + row[layout.auxiliaries + 54] = v_200; + row[layout.auxiliaries + 55] = v_201; + row[layout.auxiliaries + 56] = v_202; + row[layout.auxiliaries + 57] = v_203; + row[layout.auxiliaries + 58] = v_204; + row[layout.auxiliaries + 59] = v_205; + row[layout.auxiliaries + 60] = v_206; + row[layout.auxiliaries + 61] = v_207; + row[layout.auxiliaries + 62] = v_208; + row[layout.auxiliaries + 63] = v_209; + row[layout.auxiliaries + 64] = v_210; + row[layout.auxiliaries + 65] = v_211; + row[layout.auxiliaries + 66] = v_212; + row[layout.auxiliaries + 67] = v_213; + row[layout.auxiliaries + 68] = v_214; + row[layout.auxiliaries + 69] = v_215; + row[layout.auxiliaries + 70] = v_216; + row[layout.auxiliaries + 71] = v_217; + row[layout.auxiliaries + 72] = v_218; + row[layout.auxiliaries + 73] = v_219; + row[layout.auxiliaries + 74] = v_220; + row[layout.auxiliaries + 75] = v_221; + row[layout.auxiliaries + 76] = v_222; + row[layout.auxiliaries + 77] = v_223; + const uint64_t v_224 = seed.word(81); + const uint64_t v_225 = seed.word(82); + const uint64_t v_226 = seed.word(83); + const uint64_t v_227 = seed.word(84); + const uint64_t v_228 = seed.word(85); + const uint64_t v_229 = seed.word(86); + const uint64_t v_230 = seed.word(87); + const uint64_t v_231 = seed.word(88); + const uint64_t v_232 = seed.word(89); + const uint64_t v_233 = seed.word(90); + const uint64_t v_234 = seed.word(91); + const uint64_t v_235 = seed.word(92); + const uint64_t v_236 = seed.word(93); + const uint64_t v_237 = seed.word(94); + const uint64_t v_238 = seed.word(95); + const uint64_t v_239 = seed.word(96); + const uint64_t v_240 = seed.word(97); + const uint64_t v_241 = seed.word(98); + const uint64_t v_242 = seed.word(99); + const uint64_t v_243 = seed.word(100); + const uint64_t v_244 = seed.word(101); + const uint64_t v_245 = seed.word(102); + const uint64_t v_246 = seed.word(103); + const uint64_t v_247 = seed.word(104); + const uint64_t v_248 = seed.word(105); + const uint64_t v_249 = seed.word(106); + const uint64_t v_250 = seed.word(107); + const uint64_t v_251 = seed.word(108); + const uint64_t v_252 = seed.word(109); + const uint64_t v_253 = seed.word(110); + const uint64_t v_254 = seed.word(111); + const uint64_t v_255 = seed.word(112); + row[layout.auxiliaries + 78] = v_224; + row[layout.auxiliaries + 79] = v_225; + row[layout.auxiliaries + 80] = v_226; + row[layout.auxiliaries + 81] = v_227; + row[layout.auxiliaries + 82] = v_228; + row[layout.auxiliaries + 83] = v_229; + row[layout.auxiliaries + 84] = v_230; + row[layout.auxiliaries + 85] = v_231; + row[layout.auxiliaries + 86] = v_232; + row[layout.auxiliaries + 87] = v_233; + row[layout.auxiliaries + 88] = v_234; + row[layout.auxiliaries + 89] = v_235; + row[layout.auxiliaries + 90] = v_236; + row[layout.auxiliaries + 91] = v_237; + row[layout.auxiliaries + 92] = v_238; + row[layout.auxiliaries + 93] = v_239; + row[layout.auxiliaries + 94] = v_240; + row[layout.auxiliaries + 95] = v_241; + row[layout.auxiliaries + 96] = v_242; + row[layout.auxiliaries + 97] = v_243; + row[layout.auxiliaries + 98] = v_244; + row[layout.auxiliaries + 99] = v_245; + row[layout.auxiliaries + 100] = v_246; + row[layout.auxiliaries + 101] = v_247; + row[layout.auxiliaries + 102] = v_248; + row[layout.auxiliaries + 103] = v_249; + row[layout.auxiliaries + 104] = v_250; + row[layout.auxiliaries + 105] = v_251; + row[layout.auxiliaries + 106] = v_252; + row[layout.auxiliaries + 107] = v_253; + row[layout.auxiliaries + 108] = v_254; + row[layout.auxiliaries + 109] = v_255; + const uint64_t v_272 = seed.word(113); + const uint64_t v_273 = seed.word(114); + const uint64_t v_274 = seed.word(115); + const uint64_t v_275 = seed.word(116); + const uint64_t v_276 = seed.word(117); + const uint64_t v_277 = seed.word(118); + const uint64_t v_278 = seed.word(119); + const uint64_t v_279 = seed.word(120); + const uint64_t v_280 = seed.word(121); + const uint64_t v_281 = seed.word(122); + const uint64_t v_282 = seed.word(123); + const uint64_t v_283 = seed.word(124); + const uint64_t v_284 = seed.word(125); + const uint64_t v_285 = seed.word(126); + const uint64_t v_286 = seed.word(127); + const uint64_t v_287 = seed.word(128); + const uint64_t v_288 = seed.word(129); + const uint64_t v_289 = seed.word(130); + const uint64_t v_290 = seed.word(131); + const uint64_t v_291 = seed.word(132); + const uint64_t v_292 = seed.word(133); + const uint64_t v_293 = seed.word(134); + const uint64_t v_294 = seed.word(135); + const uint64_t v_295 = seed.word(136); + const uint64_t v_296 = seed.word(137); + const uint64_t v_297 = seed.word(138); + const uint64_t v_298 = seed.word(139); + const uint64_t v_299 = seed.word(140); + const uint64_t v_300 = seed.word(141); + const uint64_t v_301 = seed.word(142); + const uint64_t v_302 = seed.word(143); + const uint64_t v_303 = seed.word(144); + row[layout.auxiliaries + 110] = v_272; + row[layout.auxiliaries + 111] = v_273; + row[layout.auxiliaries + 112] = v_274; + row[layout.auxiliaries + 113] = v_275; + row[layout.auxiliaries + 114] = v_276; + row[layout.auxiliaries + 115] = v_277; + row[layout.auxiliaries + 116] = v_278; + row[layout.auxiliaries + 117] = v_279; + row[layout.auxiliaries + 118] = v_280; + row[layout.auxiliaries + 119] = v_281; + row[layout.auxiliaries + 120] = v_282; + row[layout.auxiliaries + 121] = v_283; + row[layout.auxiliaries + 122] = v_284; + row[layout.auxiliaries + 123] = v_285; + row[layout.auxiliaries + 124] = v_286; + row[layout.auxiliaries + 125] = v_287; + row[layout.auxiliaries + 126] = v_288; + row[layout.auxiliaries + 127] = v_289; + row[layout.auxiliaries + 128] = v_290; + row[layout.auxiliaries + 129] = v_291; + row[layout.auxiliaries + 130] = v_292; + row[layout.auxiliaries + 131] = v_293; + row[layout.auxiliaries + 132] = v_294; + row[layout.auxiliaries + 133] = v_295; + row[layout.auxiliaries + 134] = v_296; + row[layout.auxiliaries + 135] = v_297; + row[layout.auxiliaries + 136] = v_298; + row[layout.auxiliaries + 137] = v_299; + row[layout.auxiliaries + 138] = v_300; + row[layout.auxiliaries + 139] = v_301; + row[layout.auxiliaries + 140] = v_302; + row[layout.auxiliaries + 141] = v_303; + const uint64_t v_304 = seed.word(145); + row[layout.auxiliaries + 142] = v_304; + row[layout.selectors + 10] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_78(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 416 : 1168; + const Seed_multi_stark_78 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_78(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_78(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_78<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_78<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_78(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 11 || width < auxiliaries || width - auxiliaries < 143) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 416 : encoding == 0 ? 1168 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_78); +} + +template struct Seed_multi_stark_79 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 96); + case 2: return load_u32(data + 100); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 104); + case 5: return load_u32(data + 108); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 128); + case 8: return load_u8(data + 129); + case 9: return load_u8(data + 130); + case 10: return load_u8(data + 131); + case 11: return load_u8(data + 132); + case 12: return load_u8(data + 133); + case 13: return load_u8(data + 134); + case 14: return load_u8(data + 135); + case 15: return load_u8(data + 136); + case 16: return load_u8(data + 137); + case 17: return load_u8(data + 138); + case 18: return load_u8(data + 139); + case 19: return load_u8(data + 140); + case 20: return load_u8(data + 141); + case 21: return load_u8(data + 142); + case 22: return load_u8(data + 143); + case 23: return load_u8(data + 144); + case 24: return load_u8(data + 145); + case 25: return load_u8(data + 146); + case 26: return load_u8(data + 147); + case 27: return load_u8(data + 148); + case 28: return load_u8(data + 149); + case 29: return load_u8(data + 150); + case 30: return load_u8(data + 151); + case 31: return load_u8(data + 152); + case 32: return load_u8(data + 153); + case 33: return load_u8(data + 154); + case 34: return load_u8(data + 155); + case 35: return load_u8(data + 156); + case 36: return load_u8(data + 157); + case 37: return load_u8(data + 158); + case 38: return load_u8(data + 159); + case 39: return load_u8(data + 160); + case 40: return load_u8(data + 161); + case 41: return load_u8(data + 162); + case 42: return load_u8(data + 163); + case 43: return load_u8(data + 164); + case 44: return load_u8(data + 165); + case 45: return load_u8(data + 166); + case 46: return load_u8(data + 167); + case 47: return load_u8(data + 168); + case 48: return load_u8(data + 169); + case 49: return load_u8(data + 170); + case 50: return load_u8(data + 171); + case 51: return load_u8(data + 172); + case 52: return load_u8(data + 173); + case 53: return load_u8(data + 174); + case 54: return load_u8(data + 175); + case 55: return load_u8(data + 176); + case 56: return load_u8(data + 177); + case 57: return load_u8(data + 178); + case 58: return load_u8(data + 179); + case 59: return load_u8(data + 180); + case 60: return load_u8(data + 181); + case 61: return load_u8(data + 182); + case 62: return load_u8(data + 183); + case 63: return load_u8(data + 184); + case 64: return load_u8(data + 185); + case 65: return load_u8(data + 186); + case 66: return load_u8(data + 187); + case 67: return load_u8(data + 188); + case 68: return load_u8(data + 189); + case 69: return load_u8(data + 190); + case 70: return load_u8(data + 191); + case 71: return load_u8(data + 192); + case 72: return load_u8(data + 193); + case 73: return load_u8(data + 194); + case 74: return load_u8(data + 195); + case 75: return load_u8(data + 196); + case 76: return load_u8(data + 197); + case 77: return load_u8(data + 198); + case 78: return load_u8(data + 199); + case 79: return load_u8(data + 200); + case 80: return load_u8(data + 201); + case 81: return load_u8(data + 202); + case 82: return load_u8(data + 203); + case 83: return load_u8(data + 204); + case 84: return load_u8(data + 205); + case 85: return load_u8(data + 206); + case 86: return load_u8(data + 207); + case 87: return load_u8(data + 208); + case 88: return load_u8(data + 209); + case 89: return load_u8(data + 210); + case 90: return load_u8(data + 211); + case 91: return load_u8(data + 212); + case 92: return load_u8(data + 213); + case 93: return load_u8(data + 214); + case 94: return load_u8(data + 215); + case 95: return load_u8(data + 216); + case 96: return load_u8(data + 217); + case 97: return load_u8(data + 218); + case 98: return load_u8(data + 219); + case 99: return load_u8(data + 220); + case 100: return load_u8(data + 221); + case 101: return load_u8(data + 222); + case 102: return load_u8(data + 223); + case 103: return load_u8(data + 224); + case 104: return load_u8(data + 225); + case 105: return load_u8(data + 226); + case 106: return load_u8(data + 227); + case 107: return load_u8(data + 228); + case 108: return load_u8(data + 229); + case 109: return load_u8(data + 230); + case 110: return load_u8(data + 231); + case 111: return load_u8(data + 232); + case 112: return load_u8(data + 233); + case 113: return load_u8(data + 234); + case 114: return load_u8(data + 235); + case 115: return load_u8(data + 236); + case 116: return load_u8(data + 237); + case 117: return load_u8(data + 238); + case 118: return load_u8(data + 239); + case 119: return load_u8(data + 240); + case 120: return load_u8(data + 241); + case 121: return load_u8(data + 242); + case 122: return load_u8(data + 243); + case 123: return load_u8(data + 244); + case 124: return load_u8(data + 245); + case 125: return load_u8(data + 246); + case 126: return load_u8(data + 247); + case 127: return load_u8(data + 248); + case 128: return load_u8(data + 249); + case 129: return load_u8(data + 250); + case 130: return load_u8(data + 251); + case 131: return load_u8(data + 252); + case 132: return load_u8(data + 253); + case 133: return load_u8(data + 254); + case 134: return load_u8(data + 255); + case 135: return load_u8(data + 256); + case 136: return load_u8(data + 257); + case 137: return load_u8(data + 258); + case 138: return load_u8(data + 259); + case 139: return load_u8(data + 260); + case 140: return load_u8(data + 261); + case 141: return load_u8(data + 262); + case 142: return load_u8(data + 263); + case 143: return load_u8(data + 264); + case 144: return load_u8(data + 265); + case 145: return load_u32(data + 112); + case 146: return load_u32(data + 116); + case 147: return load_u64(data + 24); + case 148: return load_u64(data + 32); + case 149: return load_u64(data + 40); + case 150: return load_u64(data + 48); + case 151: return load_u64(data + 56); + case 152: return load_u64(data + 64); + case 153: return load_u64(data + 72); + case 154: return load_u64(data + 80); + case 155: return load_u32(data + 120); + case 156: return load_u32(data + 124); + case 157: return load_u64(data + 88); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_79(Seed_multi_stark_79 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_8 = 8ULL; + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + const uint64_t v_44 = seed.word(42); + const uint64_t v_45 = seed.word(43); + const uint64_t v_46 = seed.word(44); + const uint64_t v_47 = seed.word(45); + const uint64_t v_48 = seed.word(46); + const uint64_t v_49 = seed.word(47); + const uint64_t v_50 = seed.word(48); + const uint64_t v_51 = seed.word(49); + const uint64_t v_52 = seed.word(50); + const uint64_t v_53 = seed.word(51); + const uint64_t v_54 = seed.word(52); + const uint64_t v_55 = seed.word(53); + const uint64_t v_56 = seed.word(54); + const uint64_t v_57 = seed.word(55); + const uint64_t v_58 = seed.word(56); + const uint64_t v_59 = seed.word(57); + const uint64_t v_60 = seed.word(58); + const uint64_t v_61 = seed.word(59); + const uint64_t v_62 = seed.word(60); + const uint64_t v_63 = seed.word(61); + const uint64_t v_64 = seed.word(62); + const uint64_t v_65 = seed.word(63); + const uint64_t v_66 = seed.word(64); + const uint64_t v_67 = seed.word(65); + const uint64_t v_68 = seed.word(66); + const uint64_t v_69 = seed.word(67); + const uint64_t v_70 = seed.word(68); + const uint64_t v_71 = seed.word(69); + const uint64_t v_72 = seed.word(70); + row[layout.auxiliaries + 1] = v_9; + row[layout.auxiliaries + 2] = v_10; + row[layout.auxiliaries + 3] = v_11; + row[layout.auxiliaries + 4] = v_12; + row[layout.auxiliaries + 5] = v_13; + row[layout.auxiliaries + 6] = v_14; + row[layout.auxiliaries + 7] = v_15; + row[layout.auxiliaries + 8] = v_16; + row[layout.auxiliaries + 9] = v_17; + row[layout.auxiliaries + 10] = v_18; + row[layout.auxiliaries + 11] = v_19; + row[layout.auxiliaries + 12] = v_20; + row[layout.auxiliaries + 13] = v_21; + row[layout.auxiliaries + 14] = v_22; + row[layout.auxiliaries + 15] = v_23; + row[layout.auxiliaries + 16] = v_24; + row[layout.auxiliaries + 17] = v_25; + row[layout.auxiliaries + 18] = v_26; + row[layout.auxiliaries + 19] = v_27; + row[layout.auxiliaries + 20] = v_28; + row[layout.auxiliaries + 21] = v_29; + row[layout.auxiliaries + 22] = v_30; + row[layout.auxiliaries + 23] = v_31; + row[layout.auxiliaries + 24] = v_32; + row[layout.auxiliaries + 25] = v_33; + row[layout.auxiliaries + 26] = v_34; + row[layout.auxiliaries + 27] = v_35; + row[layout.auxiliaries + 28] = v_36; + row[layout.auxiliaries + 29] = v_37; + row[layout.auxiliaries + 30] = v_38; + row[layout.auxiliaries + 31] = v_39; + row[layout.auxiliaries + 32] = v_40; + row[layout.auxiliaries + 33] = v_41; + row[layout.auxiliaries + 34] = v_42; + row[layout.auxiliaries + 35] = v_43; + row[layout.auxiliaries + 36] = v_44; + row[layout.auxiliaries + 37] = v_45; + row[layout.auxiliaries + 38] = v_46; + row[layout.auxiliaries + 39] = v_47; + row[layout.auxiliaries + 40] = v_48; + row[layout.auxiliaries + 41] = v_49; + row[layout.auxiliaries + 42] = v_50; + row[layout.auxiliaries + 43] = v_51; + row[layout.auxiliaries + 44] = v_52; + row[layout.auxiliaries + 45] = v_53; + row[layout.auxiliaries + 46] = v_54; + row[layout.auxiliaries + 47] = v_55; + row[layout.auxiliaries + 48] = v_56; + row[layout.auxiliaries + 49] = v_57; + row[layout.auxiliaries + 50] = v_58; + row[layout.auxiliaries + 51] = v_59; + row[layout.auxiliaries + 52] = v_60; + row[layout.auxiliaries + 53] = v_61; + row[layout.auxiliaries + 54] = v_62; + row[layout.auxiliaries + 55] = v_63; + row[layout.auxiliaries + 56] = v_64; + row[layout.auxiliaries + 57] = v_65; + row[layout.auxiliaries + 58] = v_66; + row[layout.auxiliaries + 59] = v_67; + row[layout.auxiliaries + 60] = v_68; + row[layout.auxiliaries + 61] = v_69; + row[layout.auxiliaries + 62] = v_70; + row[layout.auxiliaries + 63] = v_71; + row[layout.auxiliaries + 64] = v_72; + switch (v_2) { + case 1023ULL: { + const uint64_t v_73 = seed.word(71); + row[layout.auxiliaries + 65] = v_73; + const uint64_t v_74 = seed.word(72); + const uint64_t v_75 = seed.word(73); + const uint64_t v_76 = seed.word(74); + const uint64_t v_77 = seed.word(75); + const uint64_t v_78 = seed.word(76); + const uint64_t v_79 = seed.word(77); + const uint64_t v_80 = seed.word(78); + const uint64_t v_81 = seed.word(79); + row[layout.auxiliaries + 66] = v_74; + row[layout.auxiliaries + 67] = v_75; + row[layout.auxiliaries + 68] = v_76; + row[layout.auxiliaries + 69] = v_77; + row[layout.auxiliaries + 70] = v_78; + row[layout.auxiliaries + 71] = v_79; + row[layout.auxiliaries + 72] = v_80; + row[layout.auxiliaries + 73] = v_81; + const uint64_t v_82 = seed.word(80); + row[layout.auxiliaries + 74] = v_82; + const uint64_t v_83 = goldilocks_mul(v_73, v_82); + row[layout.auxiliaries + 75] = v_83; + const uint64_t v_117 = seed.word(81); + const uint64_t v_118 = seed.word(82); + const uint64_t v_119 = seed.word(83); + const uint64_t v_120 = seed.word(84); + const uint64_t v_121 = seed.word(85); + const uint64_t v_122 = seed.word(86); + const uint64_t v_123 = seed.word(87); + const uint64_t v_124 = seed.word(88); + const uint64_t v_125 = seed.word(89); + const uint64_t v_126 = seed.word(90); + const uint64_t v_127 = seed.word(91); + const uint64_t v_128 = seed.word(92); + const uint64_t v_129 = seed.word(93); + const uint64_t v_130 = seed.word(94); + const uint64_t v_131 = seed.word(95); + const uint64_t v_132 = seed.word(96); + const uint64_t v_133 = seed.word(97); + const uint64_t v_134 = seed.word(98); + const uint64_t v_135 = seed.word(99); + const uint64_t v_136 = seed.word(100); + const uint64_t v_137 = seed.word(101); + const uint64_t v_138 = seed.word(102); + const uint64_t v_139 = seed.word(103); + const uint64_t v_140 = seed.word(104); + const uint64_t v_141 = seed.word(105); + const uint64_t v_142 = seed.word(106); + const uint64_t v_143 = seed.word(107); + const uint64_t v_144 = seed.word(108); + const uint64_t v_145 = seed.word(109); + const uint64_t v_146 = seed.word(110); + const uint64_t v_147 = seed.word(111); + const uint64_t v_148 = seed.word(112); + row[layout.auxiliaries + 76] = v_117; + row[layout.auxiliaries + 77] = v_118; + row[layout.auxiliaries + 78] = v_119; + row[layout.auxiliaries + 79] = v_120; + row[layout.auxiliaries + 80] = v_121; + row[layout.auxiliaries + 81] = v_122; + row[layout.auxiliaries + 82] = v_123; + row[layout.auxiliaries + 83] = v_124; + row[layout.auxiliaries + 84] = v_125; + row[layout.auxiliaries + 85] = v_126; + row[layout.auxiliaries + 86] = v_127; + row[layout.auxiliaries + 87] = v_128; + row[layout.auxiliaries + 88] = v_129; + row[layout.auxiliaries + 89] = v_130; + row[layout.auxiliaries + 90] = v_131; + row[layout.auxiliaries + 91] = v_132; + row[layout.auxiliaries + 92] = v_133; + row[layout.auxiliaries + 93] = v_134; + row[layout.auxiliaries + 94] = v_135; + row[layout.auxiliaries + 95] = v_136; + row[layout.auxiliaries + 96] = v_137; + row[layout.auxiliaries + 97] = v_138; + row[layout.auxiliaries + 98] = v_139; + row[layout.auxiliaries + 99] = v_140; + row[layout.auxiliaries + 100] = v_141; + row[layout.auxiliaries + 101] = v_142; + row[layout.auxiliaries + 102] = v_143; + row[layout.auxiliaries + 103] = v_144; + row[layout.auxiliaries + 104] = v_145; + row[layout.auxiliaries + 105] = v_146; + row[layout.auxiliaries + 106] = v_147; + row[layout.auxiliaries + 107] = v_148; + const uint64_t v_151 = seed.word(113); + const uint64_t v_152 = seed.word(114); + const uint64_t v_153 = seed.word(115); + const uint64_t v_154 = seed.word(116); + const uint64_t v_155 = seed.word(117); + const uint64_t v_156 = seed.word(118); + const uint64_t v_157 = seed.word(119); + const uint64_t v_158 = seed.word(120); + const uint64_t v_159 = seed.word(121); + const uint64_t v_160 = seed.word(122); + const uint64_t v_161 = seed.word(123); + const uint64_t v_162 = seed.word(124); + const uint64_t v_163 = seed.word(125); + const uint64_t v_164 = seed.word(126); + const uint64_t v_165 = seed.word(127); + const uint64_t v_166 = seed.word(128); + const uint64_t v_167 = seed.word(129); + const uint64_t v_168 = seed.word(130); + const uint64_t v_169 = seed.word(131); + const uint64_t v_170 = seed.word(132); + const uint64_t v_171 = seed.word(133); + const uint64_t v_172 = seed.word(134); + const uint64_t v_173 = seed.word(135); + const uint64_t v_174 = seed.word(136); + const uint64_t v_175 = seed.word(137); + const uint64_t v_176 = seed.word(138); + const uint64_t v_177 = seed.word(139); + const uint64_t v_178 = seed.word(140); + const uint64_t v_179 = seed.word(141); + const uint64_t v_180 = seed.word(142); + const uint64_t v_181 = seed.word(143); + const uint64_t v_182 = seed.word(144); + row[layout.auxiliaries + 108] = v_151; + row[layout.auxiliaries + 109] = v_152; + row[layout.auxiliaries + 110] = v_153; + row[layout.auxiliaries + 111] = v_154; + row[layout.auxiliaries + 112] = v_155; + row[layout.auxiliaries + 113] = v_156; + row[layout.auxiliaries + 114] = v_157; + row[layout.auxiliaries + 115] = v_158; + row[layout.auxiliaries + 116] = v_159; + row[layout.auxiliaries + 117] = v_160; + row[layout.auxiliaries + 118] = v_161; + row[layout.auxiliaries + 119] = v_162; + row[layout.auxiliaries + 120] = v_163; + row[layout.auxiliaries + 121] = v_164; + row[layout.auxiliaries + 122] = v_165; + row[layout.auxiliaries + 123] = v_166; + row[layout.auxiliaries + 124] = v_167; + row[layout.auxiliaries + 125] = v_168; + row[layout.auxiliaries + 126] = v_169; + row[layout.auxiliaries + 127] = v_170; + row[layout.auxiliaries + 128] = v_171; + row[layout.auxiliaries + 129] = v_172; + row[layout.auxiliaries + 130] = v_173; + row[layout.auxiliaries + 131] = v_174; + row[layout.auxiliaries + 132] = v_175; + row[layout.auxiliaries + 133] = v_176; + row[layout.auxiliaries + 134] = v_177; + row[layout.auxiliaries + 135] = v_178; + row[layout.auxiliaries + 136] = v_179; + row[layout.auxiliaries + 137] = v_180; + row[layout.auxiliaries + 138] = v_181; + row[layout.auxiliaries + 139] = v_182; + const uint64_t v_183 = seed.word(145); + row[layout.auxiliaries + 140] = v_183; + const uint64_t v_185 = seed.word(146); + row[layout.auxiliaries + 141] = v_185; + const uint64_t v_186 = seed.word(147); + const uint64_t v_187 = seed.word(148); + const uint64_t v_188 = seed.word(149); + const uint64_t v_189 = seed.word(150); + const uint64_t v_190 = seed.word(151); + const uint64_t v_191 = seed.word(152); + const uint64_t v_192 = seed.word(153); + const uint64_t v_193 = seed.word(154); + row[layout.auxiliaries + 142] = v_186; + row[layout.auxiliaries + 143] = v_187; + row[layout.auxiliaries + 144] = v_188; + row[layout.auxiliaries + 145] = v_189; + row[layout.auxiliaries + 146] = v_190; + row[layout.auxiliaries + 147] = v_191; + row[layout.auxiliaries + 148] = v_192; + row[layout.auxiliaries + 149] = v_193; + const uint64_t v_194 = seed.word(155); + row[layout.auxiliaries + 150] = v_194; + const uint64_t v_195 = seed.word(156); + row[layout.auxiliaries + 151] = v_195; + const uint64_t v_196 = seed.word(157); + row[layout.auxiliaries + 152] = v_196; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 65] = inverse(goldilocks_sub(v_2, 1023ULL)); + const uint64_t v_197 = seed.word(71); + row[layout.auxiliaries + 66] = v_197; + const uint64_t v_199 = seed.word(72); + row[layout.auxiliaries + 67] = v_199; + const uint64_t v_200 = seed.word(73); + const uint64_t v_201 = seed.word(74); + const uint64_t v_202 = seed.word(75); + const uint64_t v_203 = seed.word(76); + const uint64_t v_204 = seed.word(77); + const uint64_t v_205 = seed.word(78); + const uint64_t v_206 = seed.word(79); + const uint64_t v_207 = seed.word(80); + row[layout.auxiliaries + 68] = v_200; + row[layout.auxiliaries + 69] = v_201; + row[layout.auxiliaries + 70] = v_202; + row[layout.auxiliaries + 71] = v_203; + row[layout.auxiliaries + 72] = v_204; + row[layout.auxiliaries + 73] = v_205; + row[layout.auxiliaries + 74] = v_206; + row[layout.auxiliaries + 75] = v_207; + const uint64_t v_208 = seed.word(81); + row[layout.auxiliaries + 76] = v_208; + const uint64_t v_209 = goldilocks_mul(v_208, v_8); + const uint64_t v_210 = goldilocks_mul(v_199, v_209); + row[layout.auxiliaries + 77] = v_210; + const uint64_t v_211 = 63ULL; + const uint64_t v_212 = goldilocks_sub(v_2, v_211); + const uint64_t v_213 = uint64_t(v_212 == 0); + row[layout.auxiliaries + 78] = inverse(v_212); + row[layout.auxiliaries + 79] = v_213; + const uint64_t v_217 = seed.word(82); + const uint64_t v_218 = seed.word(83); + const uint64_t v_219 = seed.word(84); + const uint64_t v_220 = seed.word(85); + const uint64_t v_221 = seed.word(86); + const uint64_t v_222 = seed.word(87); + const uint64_t v_223 = seed.word(88); + const uint64_t v_224 = seed.word(89); + const uint64_t v_225 = seed.word(90); + const uint64_t v_226 = seed.word(91); + const uint64_t v_227 = seed.word(92); + const uint64_t v_228 = seed.word(93); + const uint64_t v_229 = seed.word(94); + const uint64_t v_230 = seed.word(95); + const uint64_t v_231 = seed.word(96); + const uint64_t v_232 = seed.word(97); + const uint64_t v_233 = seed.word(98); + const uint64_t v_234 = seed.word(99); + const uint64_t v_235 = seed.word(100); + const uint64_t v_236 = seed.word(101); + const uint64_t v_237 = seed.word(102); + const uint64_t v_238 = seed.word(103); + const uint64_t v_239 = seed.word(104); + const uint64_t v_240 = seed.word(105); + const uint64_t v_241 = seed.word(106); + const uint64_t v_242 = seed.word(107); + const uint64_t v_243 = seed.word(108); + const uint64_t v_244 = seed.word(109); + const uint64_t v_245 = seed.word(110); + const uint64_t v_246 = seed.word(111); + const uint64_t v_247 = seed.word(112); + const uint64_t v_248 = seed.word(113); + row[layout.auxiliaries + 80] = v_217; + row[layout.auxiliaries + 81] = v_218; + row[layout.auxiliaries + 82] = v_219; + row[layout.auxiliaries + 83] = v_220; + row[layout.auxiliaries + 84] = v_221; + row[layout.auxiliaries + 85] = v_222; + row[layout.auxiliaries + 86] = v_223; + row[layout.auxiliaries + 87] = v_224; + row[layout.auxiliaries + 88] = v_225; + row[layout.auxiliaries + 89] = v_226; + row[layout.auxiliaries + 90] = v_227; + row[layout.auxiliaries + 91] = v_228; + row[layout.auxiliaries + 92] = v_229; + row[layout.auxiliaries + 93] = v_230; + row[layout.auxiliaries + 94] = v_231; + row[layout.auxiliaries + 95] = v_232; + row[layout.auxiliaries + 96] = v_233; + row[layout.auxiliaries + 97] = v_234; + row[layout.auxiliaries + 98] = v_235; + row[layout.auxiliaries + 99] = v_236; + row[layout.auxiliaries + 100] = v_237; + row[layout.auxiliaries + 101] = v_238; + row[layout.auxiliaries + 102] = v_239; + row[layout.auxiliaries + 103] = v_240; + row[layout.auxiliaries + 104] = v_241; + row[layout.auxiliaries + 105] = v_242; + row[layout.auxiliaries + 106] = v_243; + row[layout.auxiliaries + 107] = v_244; + row[layout.auxiliaries + 108] = v_245; + row[layout.auxiliaries + 109] = v_246; + row[layout.auxiliaries + 110] = v_247; + row[layout.auxiliaries + 111] = v_248; + const uint64_t v_266 = seed.word(114); + const uint64_t v_267 = seed.word(115); + const uint64_t v_268 = seed.word(116); + const uint64_t v_269 = seed.word(117); + const uint64_t v_270 = seed.word(118); + const uint64_t v_271 = seed.word(119); + const uint64_t v_272 = seed.word(120); + const uint64_t v_273 = seed.word(121); + const uint64_t v_274 = seed.word(122); + const uint64_t v_275 = seed.word(123); + const uint64_t v_276 = seed.word(124); + const uint64_t v_277 = seed.word(125); + const uint64_t v_278 = seed.word(126); + const uint64_t v_279 = seed.word(127); + const uint64_t v_280 = seed.word(128); + const uint64_t v_281 = seed.word(129); + const uint64_t v_282 = seed.word(130); + const uint64_t v_283 = seed.word(131); + const uint64_t v_284 = seed.word(132); + const uint64_t v_285 = seed.word(133); + const uint64_t v_286 = seed.word(134); + const uint64_t v_287 = seed.word(135); + const uint64_t v_288 = seed.word(136); + const uint64_t v_289 = seed.word(137); + const uint64_t v_290 = seed.word(138); + const uint64_t v_291 = seed.word(139); + const uint64_t v_292 = seed.word(140); + const uint64_t v_293 = seed.word(141); + const uint64_t v_294 = seed.word(142); + const uint64_t v_295 = seed.word(143); + const uint64_t v_296 = seed.word(144); + const uint64_t v_297 = seed.word(145); + row[layout.auxiliaries + 112] = v_266; + row[layout.auxiliaries + 113] = v_267; + row[layout.auxiliaries + 114] = v_268; + row[layout.auxiliaries + 115] = v_269; + row[layout.auxiliaries + 116] = v_270; + row[layout.auxiliaries + 117] = v_271; + row[layout.auxiliaries + 118] = v_272; + row[layout.auxiliaries + 119] = v_273; + row[layout.auxiliaries + 120] = v_274; + row[layout.auxiliaries + 121] = v_275; + row[layout.auxiliaries + 122] = v_276; + row[layout.auxiliaries + 123] = v_277; + row[layout.auxiliaries + 124] = v_278; + row[layout.auxiliaries + 125] = v_279; + row[layout.auxiliaries + 126] = v_280; + row[layout.auxiliaries + 127] = v_281; + row[layout.auxiliaries + 128] = v_282; + row[layout.auxiliaries + 129] = v_283; + row[layout.auxiliaries + 130] = v_284; + row[layout.auxiliaries + 131] = v_285; + row[layout.auxiliaries + 132] = v_286; + row[layout.auxiliaries + 133] = v_287; + row[layout.auxiliaries + 134] = v_288; + row[layout.auxiliaries + 135] = v_289; + row[layout.auxiliaries + 136] = v_290; + row[layout.auxiliaries + 137] = v_291; + row[layout.auxiliaries + 138] = v_292; + row[layout.auxiliaries + 139] = v_293; + row[layout.auxiliaries + 140] = v_294; + row[layout.auxiliaries + 141] = v_295; + row[layout.auxiliaries + 142] = v_296; + row[layout.auxiliaries + 143] = v_297; + const uint64_t v_299 = seed.word(146); + row[layout.auxiliaries + 144] = v_299; + const uint64_t v_301 = seed.word(147); + row[layout.auxiliaries + 145] = v_301; + const uint64_t v_302 = seed.word(148); + row[layout.auxiliaries + 146] = v_302; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_79(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 272 : 1264; + const Seed_multi_stark_79 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_79(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_79(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_79<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_79<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_79(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 153) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 272 : encoding == 0 ? 1264 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_79); +} + +__device__ __constant__ uint64_t inverse_83_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; +template struct Seed_multi_stark_83 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u64(data + 8); + case 2: return load_u8(data + 16); + case 3: return load_u8(data + 17); + case 4: return load_u8(data + 18); + case 5: return load_u8(data + 19); + case 6: return load_u8(data + 20); + case 7: return load_u8(data + 21); + case 8: return load_u8(data + 22); + case 9: return load_u8(data + 23); + case 10: return load_u8(data + 24); + case 11: return load_u8(data + 25); + case 12: return load_u8(data + 26); + case 13: return load_u8(data + 27); + case 14: return load_u8(data + 28); + case 15: return load_u8(data + 29); + case 16: return load_u8(data + 30); + case 17: return load_u8(data + 31); + case 18: return load_u8(data + 32); + case 19: return load_u8(data + 33); + case 20: return load_u8(data + 34); + case 21: return load_u8(data + 35); + case 22: return load_u8(data + 36); + case 23: return load_u8(data + 37); + case 24: return load_u8(data + 38); + case 25: return load_u8(data + 39); + case 26: return load_u8(data + 40); + case 27: return load_u8(data + 41); + case 28: return load_u8(data + 42); + case 29: return load_u8(data + 43); + case 30: return load_u8(data + 44); + case 31: return load_u8(data + 45); + case 32: return load_u8(data + 46); + case 33: return load_u8(data + 47); + case 34: return load_u8(data + 48); + case 35: return load_u8(data + 49); + case 36: return load_u8(data + 50); + case 37: return load_u8(data + 51); + case 38: return load_u8(data + 52); + case 39: return load_u8(data + 53); + case 40: return load_u8(data + 54); + case 41: return load_u8(data + 55); + case 42: return load_u8(data + 56); + case 43: return load_u8(data + 57); + case 44: return load_u8(data + 58); + case 45: return load_u8(data + 59); + case 46: return load_u8(data + 60); + case 47: return load_u8(data + 61); + case 48: return load_u8(data + 62); + case 49: return load_u8(data + 63); + case 50: return load_u8(data + 64); + case 51: return load_u8(data + 65); + case 52: return load_u8(data + 66); + case 53: return load_u8(data + 67); + case 54: return load_u8(data + 68); + case 55: return load_u8(data + 69); + case 56: return load_u8(data + 70); + case 57: return load_u8(data + 71); + case 58: return load_u8(data + 72); + case 59: return load_u8(data + 73); + case 60: return load_u8(data + 74); + case 61: return load_u8(data + 75); + case 62: return load_u8(data + 76); + case 63: return load_u8(data + 77); + case 64: return load_u8(data + 78); + case 65: return load_u8(data + 79); + case 66: return load_u8(data + 80); + case 67: return load_u8(data + 81); + case 68: return load_u8(data + 82); + case 69: return load_u8(data + 83); + case 70: return load_u8(data + 84); + case 71: return load_u8(data + 85); + case 72: return load_u8(data + 86); + case 73: return load_u8(data + 87); + case 74: return load_u8(data + 88); + case 75: return load_u8(data + 89); + case 76: return load_u8(data + 90); + case 77: return load_u8(data + 91); + case 78: return load_u8(data + 92); + case 79: return load_u8(data + 93); + case 80: return load_u8(data + 94); + case 81: return load_u8(data + 95); + case 82: return load_u8(data + 96); + case 83: return load_u8(data + 97); + case 84: return load_u8(data + 98); + case 85: return load_u8(data + 99); + case 86: return load_u8(data + 100); + case 87: return load_u8(data + 101); + case 88: return load_u8(data + 102); + case 89: return load_u8(data + 103); + case 90: return load_u8(data + 104); + case 91: return load_u8(data + 105); + case 92: return load_u8(data + 106); + case 93: return load_u8(data + 107); + case 94: return load_u8(data + 108); + case 95: return load_u8(data + 109); + case 96: return load_u8(data + 110); + case 97: return load_u8(data + 111); + case 98: return load_u8(data + 112); + case 99: return load_u8(data + 113); + case 100: return load_u8(data + 114); + case 101: return load_u8(data + 115); + case 102: return load_u8(data + 116); + case 103: return load_u8(data + 117); + case 104: return load_u8(data + 118); + case 105: return load_u8(data + 119); + case 106: return load_u8(data + 120); + case 107: return load_u8(data + 121); + case 108: return load_u8(data + 122); + case 109: return load_u8(data + 123); + case 110: return load_u8(data + 124); + case 111: return load_u8(data + 125); + case 112: return load_u8(data + 126); + case 113: return load_u8(data + 127); + case 114: return load_u8(data + 128); + case 115: return load_u8(data + 129); + case 116: return load_u8(data + 130); + case 117: return load_u8(data + 131); + case 118: return load_u8(data + 132); + case 119: return load_u8(data + 133); + case 120: return load_u8(data + 134); + case 121: return load_u8(data + 135); + case 122: return load_u8(data + 136); + case 123: return load_u8(data + 137); + case 124: return load_u8(data + 138); + case 125: return load_u8(data + 139); + case 126: return load_u8(data + 140); + case 127: return load_u8(data + 141); + case 128: return load_u8(data + 142); + case 129: return load_u8(data + 143); + case 130: return load_u8(data + 144); + case 131: return load_u8(data + 145); + case 132: return load_u8(data + 146); + case 133: return load_u8(data + 147); + case 134: return load_u8(data + 148); + case 135: return load_u8(data + 149); + case 136: return load_u8(data + 150); + case 137: return load_u8(data + 151); + case 138: return load_u8(data + 152); + case 139: return load_u8(data + 153); + case 140: return load_u8(data + 154); + case 141: return load_u8(data + 155); + case 142: return load_u8(data + 156); + case 143: return load_u8(data + 157); + case 144: return load_u8(data + 158); + case 145: return load_u8(data + 159); + case 146: return load_u8(data + 160); + case 147: return load_u8(data + 161); + case 148: return load_u8(data + 162); + case 149: return load_u8(data + 163); + case 150: return load_u8(data + 164); + case 151: return load_u8(data + 165); + case 152: return load_u8(data + 166); + case 153: return load_u8(data + 167); + case 154: return load_u8(data + 168); + case 155: return load_u8(data + 169); + case 156: return load_u8(data + 170); + case 157: return load_u8(data + 171); + case 158: return load_u8(data + 172); + case 159: return load_u8(data + 173); + case 160: return load_u8(data + 174); + case 161: return load_u8(data + 175); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_83(Seed_multi_stark_83 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + row[20] = v_20; + const uint64_t v_21 = seed.word(22); + row[21] = v_21; + const uint64_t v_22 = seed.word(23); + row[22] = v_22; + const uint64_t v_23 = seed.word(24); + row[23] = v_23; + const uint64_t v_24 = seed.word(25); + row[24] = v_24; + const uint64_t v_25 = seed.word(26); + row[25] = v_25; + const uint64_t v_26 = seed.word(27); + row[26] = v_26; + const uint64_t v_27 = seed.word(28); + row[27] = v_27; + const uint64_t v_28 = seed.word(29); + row[28] = v_28; + const uint64_t v_29 = seed.word(30); + row[29] = v_29; + const uint64_t v_30 = seed.word(31); + row[30] = v_30; + const uint64_t v_31 = seed.word(32); + row[31] = v_31; + const uint64_t v_32 = seed.word(33); + row[32] = v_32; + const uint64_t v_33 = seed.word(34); + row[33] = v_33; + const uint64_t v_34 = seed.word(35); + row[34] = v_34; + const uint64_t v_35 = seed.word(36); + row[35] = v_35; + const uint64_t v_36 = seed.word(37); + row[36] = v_36; + const uint64_t v_37 = seed.word(38); + row[37] = v_37; + const uint64_t v_38 = seed.word(39); + row[38] = v_38; + const uint64_t v_39 = seed.word(40); + row[39] = v_39; + const uint64_t v_40 = seed.word(41); + row[40] = v_40; + const uint64_t v_41 = seed.word(42); + row[41] = v_41; + const uint64_t v_42 = seed.word(43); + row[42] = v_42; + const uint64_t v_43 = seed.word(44); + row[43] = v_43; + const uint64_t v_44 = seed.word(45); + row[44] = v_44; + const uint64_t v_45 = seed.word(46); + row[45] = v_45; + const uint64_t v_46 = seed.word(47); + row[46] = v_46; + const uint64_t v_47 = seed.word(48); + row[47] = v_47; + const uint64_t v_48 = seed.word(49); + row[48] = v_48; + const uint64_t v_49 = seed.word(50); + row[49] = v_49; + const uint64_t v_50 = seed.word(51); + row[50] = v_50; + const uint64_t v_51 = seed.word(52); + row[51] = v_51; + const uint64_t v_52 = seed.word(53); + row[52] = v_52; + const uint64_t v_53 = seed.word(54); + row[53] = v_53; + const uint64_t v_54 = seed.word(55); + row[54] = v_54; + const uint64_t v_55 = seed.word(56); + row[55] = v_55; + const uint64_t v_56 = seed.word(57); + row[56] = v_56; + const uint64_t v_57 = seed.word(58); + row[57] = v_57; + const uint64_t v_58 = seed.word(59); + row[58] = v_58; + const uint64_t v_59 = seed.word(60); + row[59] = v_59; + const uint64_t v_60 = seed.word(61); + row[60] = v_60; + const uint64_t v_61 = seed.word(62); + row[61] = v_61; + const uint64_t v_62 = seed.word(63); + row[62] = v_62; + const uint64_t v_63 = seed.word(64); + row[63] = v_63; + const uint64_t v_64 = seed.word(65); + row[64] = v_64; + const uint64_t v_65 = seed.word(66); + row[65] = v_65; + const uint64_t v_66 = seed.word(67); + row[66] = v_66; + const uint64_t v_67 = seed.word(68); + row[67] = v_67; + const uint64_t v_68 = seed.word(69); + row[68] = v_68; + const uint64_t v_69 = seed.word(70); + row[69] = v_69; + const uint64_t v_70 = seed.word(71); + row[70] = v_70; + const uint64_t v_71 = seed.word(72); + row[71] = v_71; + const uint64_t v_72 = seed.word(73); + row[72] = v_72; + const uint64_t v_73 = seed.word(74); + row[73] = v_73; + const uint64_t v_74 = seed.word(75); + row[74] = v_74; + const uint64_t v_75 = seed.word(76); + row[75] = v_75; + const uint64_t v_76 = seed.word(77); + row[76] = v_76; + const uint64_t v_77 = seed.word(78); + row[77] = v_77; + const uint64_t v_78 = seed.word(79); + row[78] = v_78; + const uint64_t v_79 = seed.word(80); + row[79] = v_79; + const uint64_t v_80 = seed.word(81); + row[80] = v_80; + const uint64_t v_81 = seed.word(82); + row[81] = v_81; + const uint64_t v_82 = seed.word(83); + row[82] = v_82; + const uint64_t v_83 = seed.word(84); + row[83] = v_83; + const uint64_t v_84 = seed.word(85); + row[84] = v_84; + const uint64_t v_85 = seed.word(86); + row[85] = v_85; + const uint64_t v_86 = seed.word(87); + row[86] = v_86; + const uint64_t v_87 = seed.word(88); + row[87] = v_87; + const uint64_t v_88 = seed.word(89); + row[88] = v_88; + const uint64_t v_89 = seed.word(90); + row[89] = v_89; + const uint64_t v_90 = seed.word(91); + row[90] = v_90; + const uint64_t v_91 = seed.word(92); + row[91] = v_91; + const uint64_t v_92 = seed.word(93); + row[92] = v_92; + const uint64_t v_93 = seed.word(94); + row[93] = v_93; + const uint64_t v_94 = seed.word(95); + row[94] = v_94; + const uint64_t v_95 = seed.word(96); + row[95] = v_95; + const uint64_t v_96 = seed.word(97); + row[96] = v_96; + const uint64_t v_97 = seed.word(98); + row[97] = v_97; + const uint64_t v_98 = seed.word(99); + row[98] = v_98; + const uint64_t v_99 = seed.word(100); + row[99] = v_99; + const uint64_t v_100 = seed.word(101); + row[100] = v_100; + const uint64_t v_101 = seed.word(102); + row[101] = v_101; + const uint64_t v_102 = seed.word(103); + row[102] = v_102; + const uint64_t v_103 = seed.word(104); + row[103] = v_103; + const uint64_t v_104 = seed.word(105); + row[104] = v_104; + const uint64_t v_105 = seed.word(106); + row[105] = v_105; + const uint64_t v_106 = seed.word(107); + row[106] = v_106; + const uint64_t v_107 = seed.word(108); + row[107] = v_107; + const uint64_t v_108 = seed.word(109); + row[108] = v_108; + const uint64_t v_109 = seed.word(110); + row[109] = v_109; + const uint64_t v_110 = seed.word(111); + row[110] = v_110; + const uint64_t v_111 = seed.word(112); + row[111] = v_111; + const uint64_t v_112 = seed.word(113); + row[112] = v_112; + const uint64_t v_113 = seed.word(114); + row[113] = v_113; + const uint64_t v_114 = seed.word(115); + row[114] = v_114; + const uint64_t v_115 = seed.word(116); + row[115] = v_115; + const uint64_t v_116 = seed.word(117); + row[116] = v_116; + const uint64_t v_117 = seed.word(118); + row[117] = v_117; + const uint64_t v_118 = seed.word(119); + row[118] = v_118; + const uint64_t v_119 = seed.word(120); + row[119] = v_119; + const uint64_t v_120 = seed.word(121); + row[120] = v_120; + const uint64_t v_121 = seed.word(122); + row[121] = v_121; + const uint64_t v_122 = seed.word(123); + row[122] = v_122; + const uint64_t v_123 = seed.word(124); + row[123] = v_123; + const uint64_t v_124 = seed.word(125); + row[124] = v_124; + const uint64_t v_125 = seed.word(126); + row[125] = v_125; + const uint64_t v_126 = seed.word(127); + row[126] = v_126; + const uint64_t v_127 = seed.word(128); + row[127] = v_127; + const uint64_t v_128 = seed.word(129); + row[128] = v_128; + switch (v_0) { + case 7ULL: { + if (v_1 > 255 || v_33 > 255) return 1; + const uint64_t v_129 = (v_1 ^ v_33); + row[layout.auxiliaries + 1] = v_129; + if (v_2 > 255 || v_34 > 255) return 1; + const uint64_t v_130 = (v_2 ^ v_34); + row[layout.auxiliaries + 2] = v_130; + if (v_3 > 255 || v_35 > 255) return 1; + const uint64_t v_131 = (v_3 ^ v_35); + row[layout.auxiliaries + 3] = v_131; + if (v_4 > 255 || v_36 > 255) return 1; + const uint64_t v_132 = (v_4 ^ v_36); + row[layout.auxiliaries + 4] = v_132; + if (v_5 > 255 || v_37 > 255) return 1; + const uint64_t v_133 = (v_5 ^ v_37); + row[layout.auxiliaries + 5] = v_133; + if (v_6 > 255 || v_38 > 255) return 1; + const uint64_t v_134 = (v_6 ^ v_38); + row[layout.auxiliaries + 6] = v_134; + if (v_7 > 255 || v_39 > 255) return 1; + const uint64_t v_135 = (v_7 ^ v_39); + row[layout.auxiliaries + 7] = v_135; + if (v_8 > 255 || v_40 > 255) return 1; + const uint64_t v_136 = (v_8 ^ v_40); + row[layout.auxiliaries + 8] = v_136; + if (v_9 > 255 || v_41 > 255) return 1; + const uint64_t v_137 = (v_9 ^ v_41); + row[layout.auxiliaries + 9] = v_137; + if (v_10 > 255 || v_42 > 255) return 1; + const uint64_t v_138 = (v_10 ^ v_42); + row[layout.auxiliaries + 10] = v_138; + if (v_11 > 255 || v_43 > 255) return 1; + const uint64_t v_139 = (v_11 ^ v_43); + row[layout.auxiliaries + 11] = v_139; + if (v_12 > 255 || v_44 > 255) return 1; + const uint64_t v_140 = (v_12 ^ v_44); + row[layout.auxiliaries + 12] = v_140; + if (v_13 > 255 || v_45 > 255) return 1; + const uint64_t v_141 = (v_13 ^ v_45); + row[layout.auxiliaries + 13] = v_141; + if (v_14 > 255 || v_46 > 255) return 1; + const uint64_t v_142 = (v_14 ^ v_46); + row[layout.auxiliaries + 14] = v_142; + if (v_15 > 255 || v_47 > 255) return 1; + const uint64_t v_143 = (v_15 ^ v_47); + row[layout.auxiliaries + 15] = v_143; + if (v_16 > 255 || v_48 > 255) return 1; + const uint64_t v_144 = (v_16 ^ v_48); + row[layout.auxiliaries + 16] = v_144; + if (v_17 > 255 || v_49 > 255) return 1; + const uint64_t v_145 = (v_17 ^ v_49); + row[layout.auxiliaries + 17] = v_145; + if (v_18 > 255 || v_50 > 255) return 1; + const uint64_t v_146 = (v_18 ^ v_50); + row[layout.auxiliaries + 18] = v_146; + if (v_19 > 255 || v_51 > 255) return 1; + const uint64_t v_147 = (v_19 ^ v_51); + row[layout.auxiliaries + 19] = v_147; + if (v_20 > 255 || v_52 > 255) return 1; + const uint64_t v_148 = (v_20 ^ v_52); + row[layout.auxiliaries + 20] = v_148; + if (v_21 > 255 || v_53 > 255) return 1; + const uint64_t v_149 = (v_21 ^ v_53); + row[layout.auxiliaries + 21] = v_149; + if (v_22 > 255 || v_54 > 255) return 1; + const uint64_t v_150 = (v_22 ^ v_54); + row[layout.auxiliaries + 22] = v_150; + if (v_23 > 255 || v_55 > 255) return 1; + const uint64_t v_151 = (v_23 ^ v_55); + row[layout.auxiliaries + 23] = v_151; + if (v_24 > 255 || v_56 > 255) return 1; + const uint64_t v_152 = (v_24 ^ v_56); + row[layout.auxiliaries + 24] = v_152; + if (v_25 > 255 || v_57 > 255) return 1; + const uint64_t v_153 = (v_25 ^ v_57); + row[layout.auxiliaries + 25] = v_153; + if (v_26 > 255 || v_58 > 255) return 1; + const uint64_t v_154 = (v_26 ^ v_58); + row[layout.auxiliaries + 26] = v_154; + if (v_27 > 255 || v_59 > 255) return 1; + const uint64_t v_155 = (v_27 ^ v_59); + row[layout.auxiliaries + 27] = v_155; + if (v_28 > 255 || v_60 > 255) return 1; + const uint64_t v_156 = (v_28 ^ v_60); + row[layout.auxiliaries + 28] = v_156; + if (v_29 > 255 || v_61 > 255) return 1; + const uint64_t v_157 = (v_29 ^ v_61); + row[layout.auxiliaries + 29] = v_157; + if (v_30 > 255 || v_62 > 255) return 1; + const uint64_t v_158 = (v_30 ^ v_62); + row[layout.auxiliaries + 30] = v_158; + if (v_31 > 255 || v_63 > 255) return 1; + const uint64_t v_159 = (v_31 ^ v_63); + row[layout.auxiliaries + 31] = v_159; + if (v_32 > 255 || v_64 > 255) return 1; + const uint64_t v_160 = (v_32 ^ v_64); + row[layout.auxiliaries + 32] = v_160; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_83_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); + const WordSum op_32 = add_words(word(v_1, v_2, v_3, v_4), word(v_17, v_18, v_19, v_20), word(v_65, v_66, v_67, v_68)); + const uint64_t v_161 = ((op_32.low >> 0) & 255ULL); + const uint64_t v_162 = ((op_32.low >> 8) & 255ULL); + const uint64_t v_163 = ((op_32.low >> 16) & 255ULL); + const uint64_t v_164 = ((op_32.low >> 24) & 255ULL); + const uint64_t v_165 = op_32.carry; + row[layout.auxiliaries + 2] = v_161; + row[layout.auxiliaries + 3] = v_162; + row[layout.auxiliaries + 4] = v_163; + row[layout.auxiliaries + 5] = v_164; + const uint64_t v_166 = 1ULL; + const uint64_t v_167 = goldilocks_sub(v_165, v_166); + const uint64_t v_168 = 2ULL; + const uint64_t v_169 = goldilocks_sub(v_165, v_168); + const uint64_t v_170 = goldilocks_mul(v_167, v_169); + row[layout.auxiliaries + 6] = v_170; + const uint64_t v_171 = goldilocks_mul(v_165, v_170); + row[layout.auxiliaries + 7] = v_171; + if (v_49 > 255 || v_161 > 255) return 1; + const uint64_t v_173 = (v_49 ^ v_161); + row[layout.auxiliaries + 8] = v_173; + if (v_50 > 255 || v_162 > 255) return 1; + const uint64_t v_174 = (v_50 ^ v_162); + row[layout.auxiliaries + 9] = v_174; + if (v_51 > 255 || v_163 > 255) return 1; + const uint64_t v_175 = (v_51 ^ v_163); + row[layout.auxiliaries + 10] = v_175; + if (v_52 > 255 || v_164 > 255) return 1; + const uint64_t v_176 = (v_52 ^ v_164); + row[layout.auxiliaries + 11] = v_176; + const WordSum op_47 = add_words(word(v_33, v_34, v_35, v_36), word(v_175, v_176, v_173, v_174)); + const uint64_t v_177 = ((op_47.low >> 0) & 255ULL); + const uint64_t v_178 = ((op_47.low >> 8) & 255ULL); + const uint64_t v_179 = ((op_47.low >> 16) & 255ULL); + const uint64_t v_180 = ((op_47.low >> 24) & 255ULL); + const uint64_t v_181 = op_47.carry; + row[layout.auxiliaries + 12] = v_177; + row[layout.auxiliaries + 13] = v_178; + row[layout.auxiliaries + 14] = v_179; + row[layout.auxiliaries + 15] = v_180; + const uint64_t v_182 = goldilocks_mul(v_181, v_181); + row[layout.auxiliaries + 16] = v_182; + if (v_17 > 255 || v_177 > 255) return 1; + const uint64_t v_183 = ((v_17 ^ v_177) >> 4); + const uint64_t v_184 = (((v_17 ^ v_177) << 4) & 255ULL); + row[layout.auxiliaries + 17] = v_183; + row[layout.auxiliaries + 18] = v_184; + if (v_18 > 255 || v_178 > 255) return 1; + const uint64_t v_185 = ((v_18 ^ v_178) >> 4); + const uint64_t v_186 = (((v_18 ^ v_178) << 4) & 255ULL); + row[layout.auxiliaries + 19] = v_185; + row[layout.auxiliaries + 20] = v_186; + if (v_19 > 255 || v_179 > 255) return 1; + const uint64_t v_187 = ((v_19 ^ v_179) >> 4); + const uint64_t v_188 = (((v_19 ^ v_179) << 4) & 255ULL); + row[layout.auxiliaries + 21] = v_187; + row[layout.auxiliaries + 22] = v_188; + if (v_20 > 255 || v_180 > 255) return 1; + const uint64_t v_189 = ((v_20 ^ v_180) >> 4); + const uint64_t v_190 = (((v_20 ^ v_180) << 4) & 255ULL); + row[layout.auxiliaries + 23] = v_189; + row[layout.auxiliaries + 24] = v_190; + const uint64_t v_191 = goldilocks_add(v_185, v_188); + const uint64_t v_192 = goldilocks_add(v_187, v_190); + const uint64_t v_193 = goldilocks_add(v_189, v_184); + const uint64_t v_194 = goldilocks_add(v_183, v_186); + const WordSum op_60 = add_words(word(v_161, v_162, v_163, v_164), word(v_191, v_192, v_193, v_194), word(v_69, v_70, v_71, v_72)); + const uint64_t v_195 = ((op_60.low >> 0) & 255ULL); + const uint64_t v_196 = ((op_60.low >> 8) & 255ULL); + const uint64_t v_197 = ((op_60.low >> 16) & 255ULL); + const uint64_t v_198 = ((op_60.low >> 24) & 255ULL); + const uint64_t v_199 = op_60.carry; + row[layout.auxiliaries + 25] = v_195; + row[layout.auxiliaries + 26] = v_196; + row[layout.auxiliaries + 27] = v_197; + row[layout.auxiliaries + 28] = v_198; + const uint64_t v_200 = goldilocks_sub(v_199, v_166); + const uint64_t v_201 = goldilocks_sub(v_199, v_168); + const uint64_t v_202 = goldilocks_mul(v_200, v_201); + row[layout.auxiliaries + 29] = v_202; + const uint64_t v_203 = goldilocks_mul(v_199, v_202); + row[layout.auxiliaries + 30] = v_203; + if (v_175 > 255 || v_195 > 255) return 1; + const uint64_t v_204 = (v_175 ^ v_195); + row[layout.auxiliaries + 31] = v_204; + if (v_176 > 255 || v_196 > 255) return 1; + const uint64_t v_205 = (v_176 ^ v_196); + row[layout.auxiliaries + 32] = v_205; + if (v_173 > 255 || v_197 > 255) return 1; + const uint64_t v_206 = (v_173 ^ v_197); + row[layout.auxiliaries + 33] = v_206; + if (v_174 > 255 || v_198 > 255) return 1; + const uint64_t v_207 = (v_174 ^ v_198); + row[layout.auxiliaries + 34] = v_207; + const WordSum op_72 = add_words(word(v_177, v_178, v_179, v_180), word(v_205, v_206, v_207, v_204)); + const uint64_t v_208 = ((op_72.low >> 0) & 255ULL); + const uint64_t v_209 = ((op_72.low >> 8) & 255ULL); + const uint64_t v_210 = ((op_72.low >> 16) & 255ULL); + const uint64_t v_211 = ((op_72.low >> 24) & 255ULL); + const uint64_t v_212 = op_72.carry; + row[layout.auxiliaries + 35] = v_208; + row[layout.auxiliaries + 36] = v_209; + row[layout.auxiliaries + 37] = v_210; + row[layout.auxiliaries + 38] = v_211; + const uint64_t v_213 = goldilocks_mul(v_212, v_212); + row[layout.auxiliaries + 39] = v_213; + if (v_191 > 255 || v_208 > 255) return 1; + const uint64_t v_214 = ((v_191 ^ v_208) >> 7); + const uint64_t v_215 = (((v_191 ^ v_208) << 1) & 255ULL); + row[layout.auxiliaries + 40] = v_214; + row[layout.auxiliaries + 41] = v_215; + if (v_192 > 255 || v_209 > 255) return 1; + const uint64_t v_216 = ((v_192 ^ v_209) >> 7); + const uint64_t v_217 = (((v_192 ^ v_209) << 1) & 255ULL); + row[layout.auxiliaries + 42] = v_216; + row[layout.auxiliaries + 43] = v_217; + if (v_193 > 255 || v_210 > 255) return 1; + const uint64_t v_218 = ((v_193 ^ v_210) >> 7); + const uint64_t v_219 = (((v_193 ^ v_210) << 1) & 255ULL); + row[layout.auxiliaries + 44] = v_218; + row[layout.auxiliaries + 45] = v_219; + if (v_194 > 255 || v_211 > 255) return 1; + const uint64_t v_220 = ((v_194 ^ v_211) >> 7); + const uint64_t v_221 = (((v_194 ^ v_211) << 1) & 255ULL); + row[layout.auxiliaries + 46] = v_220; + row[layout.auxiliaries + 47] = v_221; + const uint64_t v_222 = goldilocks_add(v_214, v_217); + const uint64_t v_223 = goldilocks_add(v_216, v_219); + const uint64_t v_224 = goldilocks_add(v_218, v_221); + const uint64_t v_225 = goldilocks_add(v_220, v_215); + const WordSum op_85 = add_words(word(v_5, v_6, v_7, v_8), word(v_21, v_22, v_23, v_24), word(v_73, v_74, v_75, v_76)); + const uint64_t v_226 = ((op_85.low >> 0) & 255ULL); + const uint64_t v_227 = ((op_85.low >> 8) & 255ULL); + const uint64_t v_228 = ((op_85.low >> 16) & 255ULL); + const uint64_t v_229 = ((op_85.low >> 24) & 255ULL); + const uint64_t v_230 = op_85.carry; + row[layout.auxiliaries + 48] = v_226; + row[layout.auxiliaries + 49] = v_227; + row[layout.auxiliaries + 50] = v_228; + row[layout.auxiliaries + 51] = v_229; + const uint64_t v_231 = goldilocks_sub(v_230, v_166); + const uint64_t v_232 = goldilocks_sub(v_230, v_168); + const uint64_t v_233 = goldilocks_mul(v_231, v_232); + row[layout.auxiliaries + 52] = v_233; + const uint64_t v_234 = goldilocks_mul(v_230, v_233); + row[layout.auxiliaries + 53] = v_234; + if (v_53 > 255 || v_226 > 255) return 1; + const uint64_t v_235 = (v_53 ^ v_226); + row[layout.auxiliaries + 54] = v_235; + if (v_54 > 255 || v_227 > 255) return 1; + const uint64_t v_236 = (v_54 ^ v_227); + row[layout.auxiliaries + 55] = v_236; + if (v_55 > 255 || v_228 > 255) return 1; + const uint64_t v_237 = (v_55 ^ v_228); + row[layout.auxiliaries + 56] = v_237; + if (v_56 > 255 || v_229 > 255) return 1; + const uint64_t v_238 = (v_56 ^ v_229); + row[layout.auxiliaries + 57] = v_238; + const WordSum op_97 = add_words(word(v_37, v_38, v_39, v_40), word(v_237, v_238, v_235, v_236)); + const uint64_t v_239 = ((op_97.low >> 0) & 255ULL); + const uint64_t v_240 = ((op_97.low >> 8) & 255ULL); + const uint64_t v_241 = ((op_97.low >> 16) & 255ULL); + const uint64_t v_242 = ((op_97.low >> 24) & 255ULL); + const uint64_t v_243 = op_97.carry; + row[layout.auxiliaries + 58] = v_239; + row[layout.auxiliaries + 59] = v_240; + row[layout.auxiliaries + 60] = v_241; + row[layout.auxiliaries + 61] = v_242; + const uint64_t v_244 = goldilocks_mul(v_243, v_243); + row[layout.auxiliaries + 62] = v_244; + if (v_21 > 255 || v_239 > 255) return 1; + const uint64_t v_245 = ((v_21 ^ v_239) >> 4); + const uint64_t v_246 = (((v_21 ^ v_239) << 4) & 255ULL); + row[layout.auxiliaries + 63] = v_245; + row[layout.auxiliaries + 64] = v_246; + if (v_22 > 255 || v_240 > 255) return 1; + const uint64_t v_247 = ((v_22 ^ v_240) >> 4); + const uint64_t v_248 = (((v_22 ^ v_240) << 4) & 255ULL); + row[layout.auxiliaries + 65] = v_247; + row[layout.auxiliaries + 66] = v_248; + if (v_23 > 255 || v_241 > 255) return 1; + const uint64_t v_249 = ((v_23 ^ v_241) >> 4); + const uint64_t v_250 = (((v_23 ^ v_241) << 4) & 255ULL); + row[layout.auxiliaries + 67] = v_249; + row[layout.auxiliaries + 68] = v_250; + if (v_24 > 255 || v_242 > 255) return 1; + const uint64_t v_251 = ((v_24 ^ v_242) >> 4); + const uint64_t v_252 = (((v_24 ^ v_242) << 4) & 255ULL); + row[layout.auxiliaries + 69] = v_251; + row[layout.auxiliaries + 70] = v_252; + const uint64_t v_253 = goldilocks_add(v_247, v_250); + const uint64_t v_254 = goldilocks_add(v_249, v_252); + const uint64_t v_255 = goldilocks_add(v_251, v_246); + const uint64_t v_256 = goldilocks_add(v_245, v_248); + const WordSum op_110 = add_words(word(v_226, v_227, v_228, v_229), word(v_253, v_254, v_255, v_256), word(v_77, v_78, v_79, v_80)); + const uint64_t v_257 = ((op_110.low >> 0) & 255ULL); + const uint64_t v_258 = ((op_110.low >> 8) & 255ULL); + const uint64_t v_259 = ((op_110.low >> 16) & 255ULL); + const uint64_t v_260 = ((op_110.low >> 24) & 255ULL); + const uint64_t v_261 = op_110.carry; + row[layout.auxiliaries + 71] = v_257; + row[layout.auxiliaries + 72] = v_258; + row[layout.auxiliaries + 73] = v_259; + row[layout.auxiliaries + 74] = v_260; + const uint64_t v_262 = goldilocks_sub(v_261, v_166); + const uint64_t v_263 = goldilocks_sub(v_261, v_168); + const uint64_t v_264 = goldilocks_mul(v_262, v_263); + row[layout.auxiliaries + 75] = v_264; + const uint64_t v_265 = goldilocks_mul(v_261, v_264); + row[layout.auxiliaries + 76] = v_265; + if (v_237 > 255 || v_257 > 255) return 1; + const uint64_t v_266 = (v_237 ^ v_257); + row[layout.auxiliaries + 77] = v_266; + if (v_238 > 255 || v_258 > 255) return 1; + const uint64_t v_267 = (v_238 ^ v_258); + row[layout.auxiliaries + 78] = v_267; + if (v_235 > 255 || v_259 > 255) return 1; + const uint64_t v_268 = (v_235 ^ v_259); + row[layout.auxiliaries + 79] = v_268; + if (v_236 > 255 || v_260 > 255) return 1; + const uint64_t v_269 = (v_236 ^ v_260); + row[layout.auxiliaries + 80] = v_269; + const WordSum op_122 = add_words(word(v_239, v_240, v_241, v_242), word(v_267, v_268, v_269, v_266)); + const uint64_t v_270 = ((op_122.low >> 0) & 255ULL); + const uint64_t v_271 = ((op_122.low >> 8) & 255ULL); + const uint64_t v_272 = ((op_122.low >> 16) & 255ULL); + const uint64_t v_273 = ((op_122.low >> 24) & 255ULL); + const uint64_t v_274 = op_122.carry; + row[layout.auxiliaries + 81] = v_270; + row[layout.auxiliaries + 82] = v_271; + row[layout.auxiliaries + 83] = v_272; + row[layout.auxiliaries + 84] = v_273; + const uint64_t v_275 = goldilocks_mul(v_274, v_274); + row[layout.auxiliaries + 85] = v_275; + if (v_253 > 255 || v_270 > 255) return 1; + const uint64_t v_276 = ((v_253 ^ v_270) >> 7); + const uint64_t v_277 = (((v_253 ^ v_270) << 1) & 255ULL); + row[layout.auxiliaries + 86] = v_276; + row[layout.auxiliaries + 87] = v_277; + if (v_254 > 255 || v_271 > 255) return 1; + const uint64_t v_278 = ((v_254 ^ v_271) >> 7); + const uint64_t v_279 = (((v_254 ^ v_271) << 1) & 255ULL); + row[layout.auxiliaries + 88] = v_278; + row[layout.auxiliaries + 89] = v_279; + if (v_255 > 255 || v_272 > 255) return 1; + const uint64_t v_280 = ((v_255 ^ v_272) >> 7); + const uint64_t v_281 = (((v_255 ^ v_272) << 1) & 255ULL); + row[layout.auxiliaries + 90] = v_280; + row[layout.auxiliaries + 91] = v_281; + if (v_256 > 255 || v_273 > 255) return 1; + const uint64_t v_282 = ((v_256 ^ v_273) >> 7); + const uint64_t v_283 = (((v_256 ^ v_273) << 1) & 255ULL); + row[layout.auxiliaries + 92] = v_282; + row[layout.auxiliaries + 93] = v_283; + const uint64_t v_284 = goldilocks_add(v_276, v_279); + const uint64_t v_285 = goldilocks_add(v_278, v_281); + const uint64_t v_286 = goldilocks_add(v_280, v_283); + const uint64_t v_287 = goldilocks_add(v_282, v_277); + const WordSum op_135 = add_words(word(v_9, v_10, v_11, v_12), word(v_25, v_26, v_27, v_28), word(v_81, v_82, v_83, v_84)); + const uint64_t v_288 = ((op_135.low >> 0) & 255ULL); + const uint64_t v_289 = ((op_135.low >> 8) & 255ULL); + const uint64_t v_290 = ((op_135.low >> 16) & 255ULL); + const uint64_t v_291 = ((op_135.low >> 24) & 255ULL); + const uint64_t v_292 = op_135.carry; + row[layout.auxiliaries + 94] = v_288; + row[layout.auxiliaries + 95] = v_289; + row[layout.auxiliaries + 96] = v_290; + row[layout.auxiliaries + 97] = v_291; + const uint64_t v_293 = goldilocks_sub(v_292, v_166); + const uint64_t v_294 = goldilocks_sub(v_292, v_168); + const uint64_t v_295 = goldilocks_mul(v_293, v_294); + row[layout.auxiliaries + 98] = v_295; + const uint64_t v_296 = goldilocks_mul(v_292, v_295); + row[layout.auxiliaries + 99] = v_296; + if (v_57 > 255 || v_288 > 255) return 1; + const uint64_t v_297 = (v_57 ^ v_288); + row[layout.auxiliaries + 100] = v_297; + if (v_58 > 255 || v_289 > 255) return 1; + const uint64_t v_298 = (v_58 ^ v_289); + row[layout.auxiliaries + 101] = v_298; + if (v_59 > 255 || v_290 > 255) return 1; + const uint64_t v_299 = (v_59 ^ v_290); + row[layout.auxiliaries + 102] = v_299; + if (v_60 > 255 || v_291 > 255) return 1; + const uint64_t v_300 = (v_60 ^ v_291); + row[layout.auxiliaries + 103] = v_300; + const WordSum op_147 = add_words(word(v_41, v_42, v_43, v_44), word(v_299, v_300, v_297, v_298)); + const uint64_t v_301 = ((op_147.low >> 0) & 255ULL); + const uint64_t v_302 = ((op_147.low >> 8) & 255ULL); + const uint64_t v_303 = ((op_147.low >> 16) & 255ULL); + const uint64_t v_304 = ((op_147.low >> 24) & 255ULL); + const uint64_t v_305 = op_147.carry; + row[layout.auxiliaries + 104] = v_301; + row[layout.auxiliaries + 105] = v_302; + row[layout.auxiliaries + 106] = v_303; + row[layout.auxiliaries + 107] = v_304; + const uint64_t v_306 = goldilocks_mul(v_305, v_305); + row[layout.auxiliaries + 108] = v_306; + if (v_25 > 255 || v_301 > 255) return 1; + const uint64_t v_307 = ((v_25 ^ v_301) >> 4); + const uint64_t v_308 = (((v_25 ^ v_301) << 4) & 255ULL); + row[layout.auxiliaries + 109] = v_307; + row[layout.auxiliaries + 110] = v_308; + if (v_26 > 255 || v_302 > 255) return 1; + const uint64_t v_309 = ((v_26 ^ v_302) >> 4); + const uint64_t v_310 = (((v_26 ^ v_302) << 4) & 255ULL); + row[layout.auxiliaries + 111] = v_309; + row[layout.auxiliaries + 112] = v_310; + if (v_27 > 255 || v_303 > 255) return 1; + const uint64_t v_311 = ((v_27 ^ v_303) >> 4); + const uint64_t v_312 = (((v_27 ^ v_303) << 4) & 255ULL); + row[layout.auxiliaries + 113] = v_311; + row[layout.auxiliaries + 114] = v_312; + if (v_28 > 255 || v_304 > 255) return 1; + const uint64_t v_313 = ((v_28 ^ v_304) >> 4); + const uint64_t v_314 = (((v_28 ^ v_304) << 4) & 255ULL); + row[layout.auxiliaries + 115] = v_313; + row[layout.auxiliaries + 116] = v_314; + const uint64_t v_315 = goldilocks_add(v_309, v_312); + const uint64_t v_316 = goldilocks_add(v_311, v_314); + const uint64_t v_317 = goldilocks_add(v_313, v_308); + const uint64_t v_318 = goldilocks_add(v_307, v_310); + const WordSum op_160 = add_words(word(v_288, v_289, v_290, v_291), word(v_315, v_316, v_317, v_318), word(v_85, v_86, v_87, v_88)); + const uint64_t v_319 = ((op_160.low >> 0) & 255ULL); + const uint64_t v_320 = ((op_160.low >> 8) & 255ULL); + const uint64_t v_321 = ((op_160.low >> 16) & 255ULL); + const uint64_t v_322 = ((op_160.low >> 24) & 255ULL); + const uint64_t v_323 = op_160.carry; + row[layout.auxiliaries + 117] = v_319; + row[layout.auxiliaries + 118] = v_320; + row[layout.auxiliaries + 119] = v_321; + row[layout.auxiliaries + 120] = v_322; + const uint64_t v_324 = goldilocks_sub(v_323, v_166); + const uint64_t v_325 = goldilocks_sub(v_323, v_168); + const uint64_t v_326 = goldilocks_mul(v_324, v_325); + row[layout.auxiliaries + 121] = v_326; + const uint64_t v_327 = goldilocks_mul(v_323, v_326); + row[layout.auxiliaries + 122] = v_327; + if (v_299 > 255 || v_319 > 255) return 1; + const uint64_t v_328 = (v_299 ^ v_319); + row[layout.auxiliaries + 123] = v_328; + if (v_300 > 255 || v_320 > 255) return 1; + const uint64_t v_329 = (v_300 ^ v_320); + row[layout.auxiliaries + 124] = v_329; + if (v_297 > 255 || v_321 > 255) return 1; + const uint64_t v_330 = (v_297 ^ v_321); + row[layout.auxiliaries + 125] = v_330; + if (v_298 > 255 || v_322 > 255) return 1; + const uint64_t v_331 = (v_298 ^ v_322); + row[layout.auxiliaries + 126] = v_331; + const WordSum op_172 = add_words(word(v_301, v_302, v_303, v_304), word(v_329, v_330, v_331, v_328)); + const uint64_t v_332 = ((op_172.low >> 0) & 255ULL); + const uint64_t v_333 = ((op_172.low >> 8) & 255ULL); + const uint64_t v_334 = ((op_172.low >> 16) & 255ULL); + const uint64_t v_335 = ((op_172.low >> 24) & 255ULL); + const uint64_t v_336 = op_172.carry; + row[layout.auxiliaries + 127] = v_332; + row[layout.auxiliaries + 128] = v_333; + row[layout.auxiliaries + 129] = v_334; + row[layout.auxiliaries + 130] = v_335; + const uint64_t v_337 = goldilocks_mul(v_336, v_336); + row[layout.auxiliaries + 131] = v_337; + if (v_315 > 255 || v_332 > 255) return 1; + const uint64_t v_338 = ((v_315 ^ v_332) >> 7); + const uint64_t v_339 = (((v_315 ^ v_332) << 1) & 255ULL); + row[layout.auxiliaries + 132] = v_338; + row[layout.auxiliaries + 133] = v_339; + if (v_316 > 255 || v_333 > 255) return 1; + const uint64_t v_340 = ((v_316 ^ v_333) >> 7); + const uint64_t v_341 = (((v_316 ^ v_333) << 1) & 255ULL); + row[layout.auxiliaries + 134] = v_340; + row[layout.auxiliaries + 135] = v_341; + if (v_317 > 255 || v_334 > 255) return 1; + const uint64_t v_342 = ((v_317 ^ v_334) >> 7); + const uint64_t v_343 = (((v_317 ^ v_334) << 1) & 255ULL); + row[layout.auxiliaries + 136] = v_342; + row[layout.auxiliaries + 137] = v_343; + if (v_318 > 255 || v_335 > 255) return 1; + const uint64_t v_344 = ((v_318 ^ v_335) >> 7); + const uint64_t v_345 = (((v_318 ^ v_335) << 1) & 255ULL); + row[layout.auxiliaries + 138] = v_344; + row[layout.auxiliaries + 139] = v_345; + const uint64_t v_346 = goldilocks_add(v_338, v_341); + const uint64_t v_347 = goldilocks_add(v_340, v_343); + const uint64_t v_348 = goldilocks_add(v_342, v_345); + const uint64_t v_349 = goldilocks_add(v_344, v_339); + const WordSum op_185 = add_words(word(v_13, v_14, v_15, v_16), word(v_29, v_30, v_31, v_32), word(v_89, v_90, v_91, v_92)); + const uint64_t v_350 = ((op_185.low >> 0) & 255ULL); + const uint64_t v_351 = ((op_185.low >> 8) & 255ULL); + const uint64_t v_352 = ((op_185.low >> 16) & 255ULL); + const uint64_t v_353 = ((op_185.low >> 24) & 255ULL); + const uint64_t v_354 = op_185.carry; + row[layout.auxiliaries + 140] = v_350; + row[layout.auxiliaries + 141] = v_351; + row[layout.auxiliaries + 142] = v_352; + row[layout.auxiliaries + 143] = v_353; + const uint64_t v_355 = goldilocks_sub(v_354, v_166); + const uint64_t v_356 = goldilocks_sub(v_354, v_168); + const uint64_t v_357 = goldilocks_mul(v_355, v_356); + row[layout.auxiliaries + 144] = v_357; + const uint64_t v_358 = goldilocks_mul(v_354, v_357); + row[layout.auxiliaries + 145] = v_358; + if (v_61 > 255 || v_350 > 255) return 1; + const uint64_t v_359 = (v_61 ^ v_350); + row[layout.auxiliaries + 146] = v_359; + if (v_62 > 255 || v_351 > 255) return 1; + const uint64_t v_360 = (v_62 ^ v_351); + row[layout.auxiliaries + 147] = v_360; + if (v_63 > 255 || v_352 > 255) return 1; + const uint64_t v_361 = (v_63 ^ v_352); + row[layout.auxiliaries + 148] = v_361; + if (v_64 > 255 || v_353 > 255) return 1; + const uint64_t v_362 = (v_64 ^ v_353); + row[layout.auxiliaries + 149] = v_362; + const WordSum op_197 = add_words(word(v_45, v_46, v_47, v_48), word(v_361, v_362, v_359, v_360)); + const uint64_t v_363 = ((op_197.low >> 0) & 255ULL); + const uint64_t v_364 = ((op_197.low >> 8) & 255ULL); + const uint64_t v_365 = ((op_197.low >> 16) & 255ULL); + const uint64_t v_366 = ((op_197.low >> 24) & 255ULL); + const uint64_t v_367 = op_197.carry; + row[layout.auxiliaries + 150] = v_363; + row[layout.auxiliaries + 151] = v_364; + row[layout.auxiliaries + 152] = v_365; + row[layout.auxiliaries + 153] = v_366; + const uint64_t v_368 = goldilocks_mul(v_367, v_367); + row[layout.auxiliaries + 154] = v_368; + if (v_29 > 255 || v_363 > 255) return 1; + const uint64_t v_369 = ((v_29 ^ v_363) >> 4); + const uint64_t v_370 = (((v_29 ^ v_363) << 4) & 255ULL); + row[layout.auxiliaries + 155] = v_369; + row[layout.auxiliaries + 156] = v_370; + if (v_30 > 255 || v_364 > 255) return 1; + const uint64_t v_371 = ((v_30 ^ v_364) >> 4); + const uint64_t v_372 = (((v_30 ^ v_364) << 4) & 255ULL); + row[layout.auxiliaries + 157] = v_371; + row[layout.auxiliaries + 158] = v_372; + if (v_31 > 255 || v_365 > 255) return 1; + const uint64_t v_373 = ((v_31 ^ v_365) >> 4); + const uint64_t v_374 = (((v_31 ^ v_365) << 4) & 255ULL); + row[layout.auxiliaries + 159] = v_373; + row[layout.auxiliaries + 160] = v_374; + if (v_32 > 255 || v_366 > 255) return 1; + const uint64_t v_375 = ((v_32 ^ v_366) >> 4); + const uint64_t v_376 = (((v_32 ^ v_366) << 4) & 255ULL); + row[layout.auxiliaries + 161] = v_375; + row[layout.auxiliaries + 162] = v_376; + const uint64_t v_377 = goldilocks_add(v_371, v_374); + const uint64_t v_378 = goldilocks_add(v_373, v_376); + const uint64_t v_379 = goldilocks_add(v_375, v_370); + const uint64_t v_380 = goldilocks_add(v_369, v_372); + const WordSum op_210 = add_words(word(v_350, v_351, v_352, v_353), word(v_377, v_378, v_379, v_380), word(v_93, v_94, v_95, v_96)); + const uint64_t v_381 = ((op_210.low >> 0) & 255ULL); + const uint64_t v_382 = ((op_210.low >> 8) & 255ULL); + const uint64_t v_383 = ((op_210.low >> 16) & 255ULL); + const uint64_t v_384 = ((op_210.low >> 24) & 255ULL); + const uint64_t v_385 = op_210.carry; + row[layout.auxiliaries + 163] = v_381; + row[layout.auxiliaries + 164] = v_382; + row[layout.auxiliaries + 165] = v_383; + row[layout.auxiliaries + 166] = v_384; + const uint64_t v_386 = goldilocks_sub(v_385, v_166); + const uint64_t v_387 = goldilocks_sub(v_385, v_168); + const uint64_t v_388 = goldilocks_mul(v_386, v_387); + row[layout.auxiliaries + 167] = v_388; + const uint64_t v_389 = goldilocks_mul(v_385, v_388); + row[layout.auxiliaries + 168] = v_389; + if (v_361 > 255 || v_381 > 255) return 1; + const uint64_t v_390 = (v_361 ^ v_381); + row[layout.auxiliaries + 169] = v_390; + if (v_362 > 255 || v_382 > 255) return 1; + const uint64_t v_391 = (v_362 ^ v_382); + row[layout.auxiliaries + 170] = v_391; + if (v_359 > 255 || v_383 > 255) return 1; + const uint64_t v_392 = (v_359 ^ v_383); + row[layout.auxiliaries + 171] = v_392; + if (v_360 > 255 || v_384 > 255) return 1; + const uint64_t v_393 = (v_360 ^ v_384); + row[layout.auxiliaries + 172] = v_393; + const WordSum op_222 = add_words(word(v_363, v_364, v_365, v_366), word(v_391, v_392, v_393, v_390)); + const uint64_t v_394 = ((op_222.low >> 0) & 255ULL); + const uint64_t v_395 = ((op_222.low >> 8) & 255ULL); + const uint64_t v_396 = ((op_222.low >> 16) & 255ULL); + const uint64_t v_397 = ((op_222.low >> 24) & 255ULL); + const uint64_t v_398 = op_222.carry; + row[layout.auxiliaries + 173] = v_394; + row[layout.auxiliaries + 174] = v_395; + row[layout.auxiliaries + 175] = v_396; + row[layout.auxiliaries + 176] = v_397; + const uint64_t v_399 = goldilocks_mul(v_398, v_398); + row[layout.auxiliaries + 177] = v_399; + if (v_377 > 255 || v_394 > 255) return 1; + const uint64_t v_400 = ((v_377 ^ v_394) >> 7); + const uint64_t v_401 = (((v_377 ^ v_394) << 1) & 255ULL); + row[layout.auxiliaries + 178] = v_400; + row[layout.auxiliaries + 179] = v_401; + if (v_378 > 255 || v_395 > 255) return 1; + const uint64_t v_402 = ((v_378 ^ v_395) >> 7); + const uint64_t v_403 = (((v_378 ^ v_395) << 1) & 255ULL); + row[layout.auxiliaries + 180] = v_402; + row[layout.auxiliaries + 181] = v_403; + if (v_379 > 255 || v_396 > 255) return 1; + const uint64_t v_404 = ((v_379 ^ v_396) >> 7); + const uint64_t v_405 = (((v_379 ^ v_396) << 1) & 255ULL); + row[layout.auxiliaries + 182] = v_404; + row[layout.auxiliaries + 183] = v_405; + if (v_380 > 255 || v_397 > 255) return 1; + const uint64_t v_406 = ((v_380 ^ v_397) >> 7); + const uint64_t v_407 = (((v_380 ^ v_397) << 1) & 255ULL); + row[layout.auxiliaries + 184] = v_406; + row[layout.auxiliaries + 185] = v_407; + const uint64_t v_408 = goldilocks_add(v_400, v_403); + const uint64_t v_409 = goldilocks_add(v_402, v_405); + const uint64_t v_410 = goldilocks_add(v_404, v_407); + const uint64_t v_411 = goldilocks_add(v_406, v_401); + const WordSum op_235 = add_words(word(v_195, v_196, v_197, v_198), word(v_284, v_285, v_286, v_287), word(v_97, v_98, v_99, v_100)); + const uint64_t v_412 = ((op_235.low >> 0) & 255ULL); + const uint64_t v_413 = ((op_235.low >> 8) & 255ULL); + const uint64_t v_414 = ((op_235.low >> 16) & 255ULL); + const uint64_t v_415 = ((op_235.low >> 24) & 255ULL); + const uint64_t v_416 = op_235.carry; + row[layout.auxiliaries + 186] = v_412; + row[layout.auxiliaries + 187] = v_413; + row[layout.auxiliaries + 188] = v_414; + row[layout.auxiliaries + 189] = v_415; + const uint64_t v_417 = goldilocks_sub(v_416, v_166); + const uint64_t v_418 = goldilocks_sub(v_416, v_168); + const uint64_t v_419 = goldilocks_mul(v_417, v_418); + row[layout.auxiliaries + 190] = v_419; + const uint64_t v_420 = goldilocks_mul(v_416, v_419); + row[layout.auxiliaries + 191] = v_420; + if (v_391 > 255 || v_412 > 255) return 1; + const uint64_t v_421 = (v_391 ^ v_412); + row[layout.auxiliaries + 192] = v_421; + if (v_392 > 255 || v_413 > 255) return 1; + const uint64_t v_422 = (v_392 ^ v_413); + row[layout.auxiliaries + 193] = v_422; + if (v_393 > 255 || v_414 > 255) return 1; + const uint64_t v_423 = (v_393 ^ v_414); + row[layout.auxiliaries + 194] = v_423; + if (v_390 > 255 || v_415 > 255) return 1; + const uint64_t v_424 = (v_390 ^ v_415); + row[layout.auxiliaries + 195] = v_424; + const WordSum op_247 = add_words(word(v_332, v_333, v_334, v_335), word(v_423, v_424, v_421, v_422)); + const uint64_t v_425 = ((op_247.low >> 0) & 255ULL); + const uint64_t v_426 = ((op_247.low >> 8) & 255ULL); + const uint64_t v_427 = ((op_247.low >> 16) & 255ULL); + const uint64_t v_428 = ((op_247.low >> 24) & 255ULL); + const uint64_t v_429 = op_247.carry; + row[layout.auxiliaries + 196] = v_425; + row[layout.auxiliaries + 197] = v_426; + row[layout.auxiliaries + 198] = v_427; + row[layout.auxiliaries + 199] = v_428; + const uint64_t v_430 = goldilocks_mul(v_429, v_429); + row[layout.auxiliaries + 200] = v_430; + if (v_284 > 255 || v_425 > 255) return 1; + const uint64_t v_431 = ((v_284 ^ v_425) >> 4); + const uint64_t v_432 = (((v_284 ^ v_425) << 4) & 255ULL); + row[layout.auxiliaries + 201] = v_431; + row[layout.auxiliaries + 202] = v_432; + if (v_285 > 255 || v_426 > 255) return 1; + const uint64_t v_433 = ((v_285 ^ v_426) >> 4); + const uint64_t v_434 = (((v_285 ^ v_426) << 4) & 255ULL); + row[layout.auxiliaries + 203] = v_433; + row[layout.auxiliaries + 204] = v_434; + if (v_286 > 255 || v_427 > 255) return 1; + const uint64_t v_435 = ((v_286 ^ v_427) >> 4); + const uint64_t v_436 = (((v_286 ^ v_427) << 4) & 255ULL); + row[layout.auxiliaries + 205] = v_435; + row[layout.auxiliaries + 206] = v_436; + if (v_287 > 255 || v_428 > 255) return 1; + const uint64_t v_437 = ((v_287 ^ v_428) >> 4); + const uint64_t v_438 = (((v_287 ^ v_428) << 4) & 255ULL); + row[layout.auxiliaries + 207] = v_437; + row[layout.auxiliaries + 208] = v_438; + const uint64_t v_439 = goldilocks_add(v_433, v_436); + const uint64_t v_440 = goldilocks_add(v_435, v_438); + const uint64_t v_441 = goldilocks_add(v_437, v_432); + const uint64_t v_442 = goldilocks_add(v_431, v_434); + const WordSum op_260 = add_words(word(v_412, v_413, v_414, v_415), word(v_439, v_440, v_441, v_442), word(v_101, v_102, v_103, v_104)); + const uint64_t v_443 = ((op_260.low >> 0) & 255ULL); + const uint64_t v_444 = ((op_260.low >> 8) & 255ULL); + const uint64_t v_445 = ((op_260.low >> 16) & 255ULL); + const uint64_t v_446 = ((op_260.low >> 24) & 255ULL); + const uint64_t v_447 = op_260.carry; + row[layout.auxiliaries + 209] = v_443; + row[layout.auxiliaries + 210] = v_444; + row[layout.auxiliaries + 211] = v_445; + row[layout.auxiliaries + 212] = v_446; + const uint64_t v_448 = goldilocks_sub(v_447, v_166); + const uint64_t v_449 = goldilocks_sub(v_447, v_168); + const uint64_t v_450 = goldilocks_mul(v_448, v_449); + row[layout.auxiliaries + 213] = v_450; + const uint64_t v_451 = goldilocks_mul(v_447, v_450); + row[layout.auxiliaries + 214] = v_451; + if (v_423 > 255 || v_443 > 255) return 1; + const uint64_t v_452 = (v_423 ^ v_443); + row[layout.auxiliaries + 215] = v_452; + if (v_424 > 255 || v_444 > 255) return 1; + const uint64_t v_453 = (v_424 ^ v_444); + row[layout.auxiliaries + 216] = v_453; + if (v_421 > 255 || v_445 > 255) return 1; + const uint64_t v_454 = (v_421 ^ v_445); + row[layout.auxiliaries + 217] = v_454; + if (v_422 > 255 || v_446 > 255) return 1; + const uint64_t v_455 = (v_422 ^ v_446); + row[layout.auxiliaries + 218] = v_455; + const WordSum op_272 = add_words(word(v_425, v_426, v_427, v_428), word(v_453, v_454, v_455, v_452)); + const uint64_t v_456 = ((op_272.low >> 0) & 255ULL); + const uint64_t v_457 = ((op_272.low >> 8) & 255ULL); + const uint64_t v_458 = ((op_272.low >> 16) & 255ULL); + const uint64_t v_459 = ((op_272.low >> 24) & 255ULL); + const uint64_t v_460 = op_272.carry; + row[layout.auxiliaries + 219] = v_456; + row[layout.auxiliaries + 220] = v_457; + row[layout.auxiliaries + 221] = v_458; + row[layout.auxiliaries + 222] = v_459; + const uint64_t v_461 = goldilocks_mul(v_460, v_460); + row[layout.auxiliaries + 223] = v_461; + if (v_439 > 255 || v_456 > 255) return 1; + const uint64_t v_462 = ((v_439 ^ v_456) >> 7); + const uint64_t v_463 = (((v_439 ^ v_456) << 1) & 255ULL); + row[layout.auxiliaries + 224] = v_462; + row[layout.auxiliaries + 225] = v_463; + if (v_440 > 255 || v_457 > 255) return 1; + const uint64_t v_464 = ((v_440 ^ v_457) >> 7); + const uint64_t v_465 = (((v_440 ^ v_457) << 1) & 255ULL); + row[layout.auxiliaries + 226] = v_464; + row[layout.auxiliaries + 227] = v_465; + if (v_441 > 255 || v_458 > 255) return 1; + const uint64_t v_466 = ((v_441 ^ v_458) >> 7); + const uint64_t v_467 = (((v_441 ^ v_458) << 1) & 255ULL); + row[layout.auxiliaries + 228] = v_466; + row[layout.auxiliaries + 229] = v_467; + if (v_442 > 255 || v_459 > 255) return 1; + const uint64_t v_468 = ((v_442 ^ v_459) >> 7); + const uint64_t v_469 = (((v_442 ^ v_459) << 1) & 255ULL); + row[layout.auxiliaries + 230] = v_468; + row[layout.auxiliaries + 231] = v_469; + const WordSum op_285 = add_words(word(v_257, v_258, v_259, v_260), word(v_346, v_347, v_348, v_349), word(v_105, v_106, v_107, v_108)); + const uint64_t v_474 = ((op_285.low >> 0) & 255ULL); + const uint64_t v_475 = ((op_285.low >> 8) & 255ULL); + const uint64_t v_476 = ((op_285.low >> 16) & 255ULL); + const uint64_t v_477 = ((op_285.low >> 24) & 255ULL); + const uint64_t v_478 = op_285.carry; + row[layout.auxiliaries + 232] = v_474; + row[layout.auxiliaries + 233] = v_475; + row[layout.auxiliaries + 234] = v_476; + row[layout.auxiliaries + 235] = v_477; + const uint64_t v_479 = goldilocks_sub(v_478, v_166); + const uint64_t v_480 = goldilocks_sub(v_478, v_168); + const uint64_t v_481 = goldilocks_mul(v_479, v_480); + row[layout.auxiliaries + 236] = v_481; + const uint64_t v_482 = goldilocks_mul(v_478, v_481); + row[layout.auxiliaries + 237] = v_482; + if (v_205 > 255 || v_474 > 255) return 1; + const uint64_t v_483 = (v_205 ^ v_474); + row[layout.auxiliaries + 238] = v_483; + if (v_206 > 255 || v_475 > 255) return 1; + const uint64_t v_484 = (v_206 ^ v_475); + row[layout.auxiliaries + 239] = v_484; + if (v_207 > 255 || v_476 > 255) return 1; + const uint64_t v_485 = (v_207 ^ v_476); + row[layout.auxiliaries + 240] = v_485; + if (v_204 > 255 || v_477 > 255) return 1; + const uint64_t v_486 = (v_204 ^ v_477); + row[layout.auxiliaries + 241] = v_486; + const WordSum op_297 = add_words(word(v_394, v_395, v_396, v_397), word(v_485, v_486, v_483, v_484)); + const uint64_t v_487 = ((op_297.low >> 0) & 255ULL); + const uint64_t v_488 = ((op_297.low >> 8) & 255ULL); + const uint64_t v_489 = ((op_297.low >> 16) & 255ULL); + const uint64_t v_490 = ((op_297.low >> 24) & 255ULL); + const uint64_t v_491 = op_297.carry; + row[layout.auxiliaries + 242] = v_487; + row[layout.auxiliaries + 243] = v_488; + row[layout.auxiliaries + 244] = v_489; + row[layout.auxiliaries + 245] = v_490; + const uint64_t v_492 = goldilocks_mul(v_491, v_491); + row[layout.auxiliaries + 246] = v_492; + if (v_346 > 255 || v_487 > 255) return 1; + const uint64_t v_493 = ((v_346 ^ v_487) >> 4); + const uint64_t v_494 = (((v_346 ^ v_487) << 4) & 255ULL); + row[layout.auxiliaries + 247] = v_493; + row[layout.auxiliaries + 248] = v_494; + if (v_347 > 255 || v_488 > 255) return 1; + const uint64_t v_495 = ((v_347 ^ v_488) >> 4); + const uint64_t v_496 = (((v_347 ^ v_488) << 4) & 255ULL); + row[layout.auxiliaries + 249] = v_495; + row[layout.auxiliaries + 250] = v_496; + if (v_348 > 255 || v_489 > 255) return 1; + const uint64_t v_497 = ((v_348 ^ v_489) >> 4); + const uint64_t v_498 = (((v_348 ^ v_489) << 4) & 255ULL); + row[layout.auxiliaries + 251] = v_497; + row[layout.auxiliaries + 252] = v_498; + if (v_349 > 255 || v_490 > 255) return 1; + const uint64_t v_499 = ((v_349 ^ v_490) >> 4); + const uint64_t v_500 = (((v_349 ^ v_490) << 4) & 255ULL); + row[layout.auxiliaries + 253] = v_499; + row[layout.auxiliaries + 254] = v_500; + const uint64_t v_501 = goldilocks_add(v_495, v_498); + const uint64_t v_502 = goldilocks_add(v_497, v_500); + const uint64_t v_503 = goldilocks_add(v_499, v_494); + const uint64_t v_504 = goldilocks_add(v_493, v_496); + const WordSum op_310 = add_words(word(v_474, v_475, v_476, v_477), word(v_501, v_502, v_503, v_504), word(v_109, v_110, v_111, v_112)); + const uint64_t v_505 = ((op_310.low >> 0) & 255ULL); + const uint64_t v_506 = ((op_310.low >> 8) & 255ULL); + const uint64_t v_507 = ((op_310.low >> 16) & 255ULL); + const uint64_t v_508 = ((op_310.low >> 24) & 255ULL); + const uint64_t v_509 = op_310.carry; + row[layout.auxiliaries + 255] = v_505; + row[layout.auxiliaries + 256] = v_506; + row[layout.auxiliaries + 257] = v_507; + row[layout.auxiliaries + 258] = v_508; + const uint64_t v_510 = goldilocks_sub(v_509, v_166); + const uint64_t v_511 = goldilocks_sub(v_509, v_168); + const uint64_t v_512 = goldilocks_mul(v_510, v_511); + row[layout.auxiliaries + 259] = v_512; + const uint64_t v_513 = goldilocks_mul(v_509, v_512); + row[layout.auxiliaries + 260] = v_513; + if (v_485 > 255 || v_505 > 255) return 1; + const uint64_t v_514 = (v_485 ^ v_505); + row[layout.auxiliaries + 261] = v_514; + if (v_486 > 255 || v_506 > 255) return 1; + const uint64_t v_515 = (v_486 ^ v_506); + row[layout.auxiliaries + 262] = v_515; + if (v_483 > 255 || v_507 > 255) return 1; + const uint64_t v_516 = (v_483 ^ v_507); + row[layout.auxiliaries + 263] = v_516; + if (v_484 > 255 || v_508 > 255) return 1; + const uint64_t v_517 = (v_484 ^ v_508); + row[layout.auxiliaries + 264] = v_517; + const WordSum op_322 = add_words(word(v_487, v_488, v_489, v_490), word(v_515, v_516, v_517, v_514)); + const uint64_t v_518 = ((op_322.low >> 0) & 255ULL); + const uint64_t v_519 = ((op_322.low >> 8) & 255ULL); + const uint64_t v_520 = ((op_322.low >> 16) & 255ULL); + const uint64_t v_521 = ((op_322.low >> 24) & 255ULL); + const uint64_t v_522 = op_322.carry; + row[layout.auxiliaries + 265] = v_518; + row[layout.auxiliaries + 266] = v_519; + row[layout.auxiliaries + 267] = v_520; + row[layout.auxiliaries + 268] = v_521; + const uint64_t v_523 = goldilocks_mul(v_522, v_522); + row[layout.auxiliaries + 269] = v_523; + if (v_501 > 255 || v_518 > 255) return 1; + const uint64_t v_524 = ((v_501 ^ v_518) >> 7); + const uint64_t v_525 = (((v_501 ^ v_518) << 1) & 255ULL); + row[layout.auxiliaries + 270] = v_524; + row[layout.auxiliaries + 271] = v_525; + if (v_502 > 255 || v_519 > 255) return 1; + const uint64_t v_526 = ((v_502 ^ v_519) >> 7); + const uint64_t v_527 = (((v_502 ^ v_519) << 1) & 255ULL); + row[layout.auxiliaries + 272] = v_526; + row[layout.auxiliaries + 273] = v_527; + if (v_503 > 255 || v_520 > 255) return 1; + const uint64_t v_528 = ((v_503 ^ v_520) >> 7); + const uint64_t v_529 = (((v_503 ^ v_520) << 1) & 255ULL); + row[layout.auxiliaries + 274] = v_528; + row[layout.auxiliaries + 275] = v_529; + if (v_504 > 255 || v_521 > 255) return 1; + const uint64_t v_530 = ((v_504 ^ v_521) >> 7); + const uint64_t v_531 = (((v_504 ^ v_521) << 1) & 255ULL); + row[layout.auxiliaries + 276] = v_530; + row[layout.auxiliaries + 277] = v_531; + const WordSum op_335 = add_words(word(v_319, v_320, v_321, v_322), word(v_408, v_409, v_410, v_411), word(v_113, v_114, v_115, v_116)); + const uint64_t v_536 = ((op_335.low >> 0) & 255ULL); + const uint64_t v_537 = ((op_335.low >> 8) & 255ULL); + const uint64_t v_538 = ((op_335.low >> 16) & 255ULL); + const uint64_t v_539 = ((op_335.low >> 24) & 255ULL); + const uint64_t v_540 = op_335.carry; + row[layout.auxiliaries + 278] = v_536; + row[layout.auxiliaries + 279] = v_537; + row[layout.auxiliaries + 280] = v_538; + row[layout.auxiliaries + 281] = v_539; + const uint64_t v_541 = goldilocks_sub(v_540, v_166); + const uint64_t v_542 = goldilocks_sub(v_540, v_168); + const uint64_t v_543 = goldilocks_mul(v_541, v_542); + row[layout.auxiliaries + 282] = v_543; + const uint64_t v_544 = goldilocks_mul(v_540, v_543); + row[layout.auxiliaries + 283] = v_544; + if (v_267 > 255 || v_536 > 255) return 1; + const uint64_t v_545 = (v_267 ^ v_536); + row[layout.auxiliaries + 284] = v_545; + if (v_268 > 255 || v_537 > 255) return 1; + const uint64_t v_546 = (v_268 ^ v_537); + row[layout.auxiliaries + 285] = v_546; + if (v_269 > 255 || v_538 > 255) return 1; + const uint64_t v_547 = (v_269 ^ v_538); + row[layout.auxiliaries + 286] = v_547; + if (v_266 > 255 || v_539 > 255) return 1; + const uint64_t v_548 = (v_266 ^ v_539); + row[layout.auxiliaries + 287] = v_548; + const WordSum op_347 = add_words(word(v_208, v_209, v_210, v_211), word(v_547, v_548, v_545, v_546)); + const uint64_t v_549 = ((op_347.low >> 0) & 255ULL); + const uint64_t v_550 = ((op_347.low >> 8) & 255ULL); + const uint64_t v_551 = ((op_347.low >> 16) & 255ULL); + const uint64_t v_552 = ((op_347.low >> 24) & 255ULL); + const uint64_t v_553 = op_347.carry; + row[layout.auxiliaries + 288] = v_549; + row[layout.auxiliaries + 289] = v_550; + row[layout.auxiliaries + 290] = v_551; + row[layout.auxiliaries + 291] = v_552; + const uint64_t v_554 = goldilocks_mul(v_553, v_553); + row[layout.auxiliaries + 292] = v_554; + if (v_408 > 255 || v_549 > 255) return 1; + const uint64_t v_555 = ((v_408 ^ v_549) >> 4); + const uint64_t v_556 = (((v_408 ^ v_549) << 4) & 255ULL); + row[layout.auxiliaries + 293] = v_555; + row[layout.auxiliaries + 294] = v_556; + if (v_409 > 255 || v_550 > 255) return 1; + const uint64_t v_557 = ((v_409 ^ v_550) >> 4); + const uint64_t v_558 = (((v_409 ^ v_550) << 4) & 255ULL); + row[layout.auxiliaries + 295] = v_557; + row[layout.auxiliaries + 296] = v_558; + if (v_410 > 255 || v_551 > 255) return 1; + const uint64_t v_559 = ((v_410 ^ v_551) >> 4); + const uint64_t v_560 = (((v_410 ^ v_551) << 4) & 255ULL); + row[layout.auxiliaries + 297] = v_559; + row[layout.auxiliaries + 298] = v_560; + if (v_411 > 255 || v_552 > 255) return 1; + const uint64_t v_561 = ((v_411 ^ v_552) >> 4); + const uint64_t v_562 = (((v_411 ^ v_552) << 4) & 255ULL); + row[layout.auxiliaries + 299] = v_561; + row[layout.auxiliaries + 300] = v_562; + const uint64_t v_563 = goldilocks_add(v_557, v_560); + const uint64_t v_564 = goldilocks_add(v_559, v_562); + const uint64_t v_565 = goldilocks_add(v_561, v_556); + const uint64_t v_566 = goldilocks_add(v_555, v_558); + const WordSum op_360 = add_words(word(v_536, v_537, v_538, v_539), word(v_563, v_564, v_565, v_566), word(v_117, v_118, v_119, v_120)); + const uint64_t v_567 = ((op_360.low >> 0) & 255ULL); + const uint64_t v_568 = ((op_360.low >> 8) & 255ULL); + const uint64_t v_569 = ((op_360.low >> 16) & 255ULL); + const uint64_t v_570 = ((op_360.low >> 24) & 255ULL); + const uint64_t v_571 = op_360.carry; + row[layout.auxiliaries + 301] = v_567; + row[layout.auxiliaries + 302] = v_568; + row[layout.auxiliaries + 303] = v_569; + row[layout.auxiliaries + 304] = v_570; + const uint64_t v_572 = goldilocks_sub(v_571, v_166); + const uint64_t v_573 = goldilocks_sub(v_571, v_168); + const uint64_t v_574 = goldilocks_mul(v_572, v_573); + row[layout.auxiliaries + 305] = v_574; + const uint64_t v_575 = goldilocks_mul(v_571, v_574); + row[layout.auxiliaries + 306] = v_575; + if (v_547 > 255 || v_567 > 255) return 1; + const uint64_t v_576 = (v_547 ^ v_567); + row[layout.auxiliaries + 307] = v_576; + if (v_548 > 255 || v_568 > 255) return 1; + const uint64_t v_577 = (v_548 ^ v_568); + row[layout.auxiliaries + 308] = v_577; + if (v_545 > 255 || v_569 > 255) return 1; + const uint64_t v_578 = (v_545 ^ v_569); + row[layout.auxiliaries + 309] = v_578; + if (v_546 > 255 || v_570 > 255) return 1; + const uint64_t v_579 = (v_546 ^ v_570); + row[layout.auxiliaries + 310] = v_579; + const WordSum op_372 = add_words(word(v_549, v_550, v_551, v_552), word(v_577, v_578, v_579, v_576)); + const uint64_t v_580 = ((op_372.low >> 0) & 255ULL); + const uint64_t v_581 = ((op_372.low >> 8) & 255ULL); + const uint64_t v_582 = ((op_372.low >> 16) & 255ULL); + const uint64_t v_583 = ((op_372.low >> 24) & 255ULL); + const uint64_t v_584 = op_372.carry; + row[layout.auxiliaries + 311] = v_580; + row[layout.auxiliaries + 312] = v_581; + row[layout.auxiliaries + 313] = v_582; + row[layout.auxiliaries + 314] = v_583; + const uint64_t v_585 = goldilocks_mul(v_584, v_584); + row[layout.auxiliaries + 315] = v_585; + if (v_563 > 255 || v_580 > 255) return 1; + const uint64_t v_586 = ((v_563 ^ v_580) >> 7); + const uint64_t v_587 = (((v_563 ^ v_580) << 1) & 255ULL); + row[layout.auxiliaries + 316] = v_586; + row[layout.auxiliaries + 317] = v_587; + if (v_564 > 255 || v_581 > 255) return 1; + const uint64_t v_588 = ((v_564 ^ v_581) >> 7); + const uint64_t v_589 = (((v_564 ^ v_581) << 1) & 255ULL); + row[layout.auxiliaries + 318] = v_588; + row[layout.auxiliaries + 319] = v_589; + if (v_565 > 255 || v_582 > 255) return 1; + const uint64_t v_590 = ((v_565 ^ v_582) >> 7); + const uint64_t v_591 = (((v_565 ^ v_582) << 1) & 255ULL); + row[layout.auxiliaries + 320] = v_590; + row[layout.auxiliaries + 321] = v_591; + if (v_566 > 255 || v_583 > 255) return 1; + const uint64_t v_592 = ((v_566 ^ v_583) >> 7); + const uint64_t v_593 = (((v_566 ^ v_583) << 1) & 255ULL); + row[layout.auxiliaries + 322] = v_592; + row[layout.auxiliaries + 323] = v_593; + const WordSum op_385 = add_words(word(v_381, v_382, v_383, v_384), word(v_222, v_223, v_224, v_225), word(v_121, v_122, v_123, v_124)); + const uint64_t v_598 = ((op_385.low >> 0) & 255ULL); + const uint64_t v_599 = ((op_385.low >> 8) & 255ULL); + const uint64_t v_600 = ((op_385.low >> 16) & 255ULL); + const uint64_t v_601 = ((op_385.low >> 24) & 255ULL); + const uint64_t v_602 = op_385.carry; + row[layout.auxiliaries + 324] = v_598; + row[layout.auxiliaries + 325] = v_599; + row[layout.auxiliaries + 326] = v_600; + row[layout.auxiliaries + 327] = v_601; + const uint64_t v_603 = goldilocks_sub(v_602, v_166); + const uint64_t v_604 = goldilocks_sub(v_602, v_168); + const uint64_t v_605 = goldilocks_mul(v_603, v_604); + row[layout.auxiliaries + 328] = v_605; + const uint64_t v_606 = goldilocks_mul(v_602, v_605); + row[layout.auxiliaries + 329] = v_606; + if (v_329 > 255 || v_598 > 255) return 1; + const uint64_t v_607 = (v_329 ^ v_598); + row[layout.auxiliaries + 330] = v_607; + if (v_330 > 255 || v_599 > 255) return 1; + const uint64_t v_608 = (v_330 ^ v_599); + row[layout.auxiliaries + 331] = v_608; + if (v_331 > 255 || v_600 > 255) return 1; + const uint64_t v_609 = (v_331 ^ v_600); + row[layout.auxiliaries + 332] = v_609; + if (v_328 > 255 || v_601 > 255) return 1; + const uint64_t v_610 = (v_328 ^ v_601); + row[layout.auxiliaries + 333] = v_610; + const WordSum op_397 = add_words(word(v_270, v_271, v_272, v_273), word(v_609, v_610, v_607, v_608)); + const uint64_t v_611 = ((op_397.low >> 0) & 255ULL); + const uint64_t v_612 = ((op_397.low >> 8) & 255ULL); + const uint64_t v_613 = ((op_397.low >> 16) & 255ULL); + const uint64_t v_614 = ((op_397.low >> 24) & 255ULL); + const uint64_t v_615 = op_397.carry; + row[layout.auxiliaries + 334] = v_611; + row[layout.auxiliaries + 335] = v_612; + row[layout.auxiliaries + 336] = v_613; + row[layout.auxiliaries + 337] = v_614; + const uint64_t v_616 = goldilocks_mul(v_615, v_615); + row[layout.auxiliaries + 338] = v_616; + if (v_222 > 255 || v_611 > 255) return 1; + const uint64_t v_617 = ((v_222 ^ v_611) >> 4); + const uint64_t v_618 = (((v_222 ^ v_611) << 4) & 255ULL); + row[layout.auxiliaries + 339] = v_617; + row[layout.auxiliaries + 340] = v_618; + if (v_223 > 255 || v_612 > 255) return 1; + const uint64_t v_619 = ((v_223 ^ v_612) >> 4); + const uint64_t v_620 = (((v_223 ^ v_612) << 4) & 255ULL); + row[layout.auxiliaries + 341] = v_619; + row[layout.auxiliaries + 342] = v_620; + if (v_224 > 255 || v_613 > 255) return 1; + const uint64_t v_621 = ((v_224 ^ v_613) >> 4); + const uint64_t v_622 = (((v_224 ^ v_613) << 4) & 255ULL); + row[layout.auxiliaries + 343] = v_621; + row[layout.auxiliaries + 344] = v_622; + if (v_225 > 255 || v_614 > 255) return 1; + const uint64_t v_623 = ((v_225 ^ v_614) >> 4); + const uint64_t v_624 = (((v_225 ^ v_614) << 4) & 255ULL); + row[layout.auxiliaries + 345] = v_623; + row[layout.auxiliaries + 346] = v_624; + const uint64_t v_625 = goldilocks_add(v_619, v_622); + const uint64_t v_626 = goldilocks_add(v_621, v_624); + const uint64_t v_627 = goldilocks_add(v_623, v_618); + const uint64_t v_628 = goldilocks_add(v_617, v_620); + const WordSum op_410 = add_words(word(v_598, v_599, v_600, v_601), word(v_625, v_626, v_627, v_628), word(v_125, v_126, v_127, v_128)); + const uint64_t v_629 = ((op_410.low >> 0) & 255ULL); + const uint64_t v_630 = ((op_410.low >> 8) & 255ULL); + const uint64_t v_631 = ((op_410.low >> 16) & 255ULL); + const uint64_t v_632 = ((op_410.low >> 24) & 255ULL); + const uint64_t v_633 = op_410.carry; + row[layout.auxiliaries + 347] = v_629; + row[layout.auxiliaries + 348] = v_630; + row[layout.auxiliaries + 349] = v_631; + row[layout.auxiliaries + 350] = v_632; + const uint64_t v_634 = goldilocks_sub(v_633, v_166); + const uint64_t v_635 = goldilocks_sub(v_633, v_168); + const uint64_t v_636 = goldilocks_mul(v_634, v_635); + row[layout.auxiliaries + 351] = v_636; + const uint64_t v_637 = goldilocks_mul(v_633, v_636); + row[layout.auxiliaries + 352] = v_637; + if (v_609 > 255 || v_629 > 255) return 1; + const uint64_t v_638 = (v_609 ^ v_629); + row[layout.auxiliaries + 353] = v_638; + if (v_610 > 255 || v_630 > 255) return 1; + const uint64_t v_639 = (v_610 ^ v_630); + row[layout.auxiliaries + 354] = v_639; + if (v_607 > 255 || v_631 > 255) return 1; + const uint64_t v_640 = (v_607 ^ v_631); + row[layout.auxiliaries + 355] = v_640; + if (v_608 > 255 || v_632 > 255) return 1; + const uint64_t v_641 = (v_608 ^ v_632); + row[layout.auxiliaries + 356] = v_641; + const WordSum op_422 = add_words(word(v_611, v_612, v_613, v_614), word(v_639, v_640, v_641, v_638)); + const uint64_t v_642 = ((op_422.low >> 0) & 255ULL); + const uint64_t v_643 = ((op_422.low >> 8) & 255ULL); + const uint64_t v_644 = ((op_422.low >> 16) & 255ULL); + const uint64_t v_645 = ((op_422.low >> 24) & 255ULL); + const uint64_t v_646 = op_422.carry; + row[layout.auxiliaries + 357] = v_642; + row[layout.auxiliaries + 358] = v_643; + row[layout.auxiliaries + 359] = v_644; + row[layout.auxiliaries + 360] = v_645; + const uint64_t v_647 = goldilocks_mul(v_646, v_646); + row[layout.auxiliaries + 361] = v_647; + if (v_625 > 255 || v_642 > 255) return 1; + const uint64_t v_648 = ((v_625 ^ v_642) >> 7); + const uint64_t v_649 = (((v_625 ^ v_642) << 1) & 255ULL); + row[layout.auxiliaries + 362] = v_648; + row[layout.auxiliaries + 363] = v_649; + if (v_626 > 255 || v_643 > 255) return 1; + const uint64_t v_650 = ((v_626 ^ v_643) >> 7); + const uint64_t v_651 = (((v_626 ^ v_643) << 1) & 255ULL); + row[layout.auxiliaries + 364] = v_650; + row[layout.auxiliaries + 365] = v_651; + if (v_627 > 255 || v_644 > 255) return 1; + const uint64_t v_652 = ((v_627 ^ v_644) >> 7); + const uint64_t v_653 = (((v_627 ^ v_644) << 1) & 255ULL); + row[layout.auxiliaries + 366] = v_652; + row[layout.auxiliaries + 367] = v_653; + if (v_628 > 255 || v_645 > 255) return 1; + const uint64_t v_654 = ((v_628 ^ v_645) >> 7); + const uint64_t v_655 = (((v_628 ^ v_645) << 1) & 255ULL); + row[layout.auxiliaries + 368] = v_654; + row[layout.auxiliaries + 369] = v_655; + const uint64_t v_661 = seed.word(130); + const uint64_t v_662 = seed.word(131); + const uint64_t v_663 = seed.word(132); + const uint64_t v_664 = seed.word(133); + const uint64_t v_665 = seed.word(134); + const uint64_t v_666 = seed.word(135); + const uint64_t v_667 = seed.word(136); + const uint64_t v_668 = seed.word(137); + const uint64_t v_669 = seed.word(138); + const uint64_t v_670 = seed.word(139); + const uint64_t v_671 = seed.word(140); + const uint64_t v_672 = seed.word(141); + const uint64_t v_673 = seed.word(142); + const uint64_t v_674 = seed.word(143); + const uint64_t v_675 = seed.word(144); + const uint64_t v_676 = seed.word(145); + const uint64_t v_677 = seed.word(146); + const uint64_t v_678 = seed.word(147); + const uint64_t v_679 = seed.word(148); + const uint64_t v_680 = seed.word(149); + const uint64_t v_681 = seed.word(150); + const uint64_t v_682 = seed.word(151); + const uint64_t v_683 = seed.word(152); + const uint64_t v_684 = seed.word(153); + const uint64_t v_685 = seed.word(154); + const uint64_t v_686 = seed.word(155); + const uint64_t v_687 = seed.word(156); + const uint64_t v_688 = seed.word(157); + const uint64_t v_689 = seed.word(158); + const uint64_t v_690 = seed.word(159); + const uint64_t v_691 = seed.word(160); + const uint64_t v_692 = seed.word(161); + row[layout.auxiliaries + 370] = v_661; + row[layout.auxiliaries + 371] = v_662; + row[layout.auxiliaries + 372] = v_663; + row[layout.auxiliaries + 373] = v_664; + row[layout.auxiliaries + 374] = v_665; + row[layout.auxiliaries + 375] = v_666; + row[layout.auxiliaries + 376] = v_667; + row[layout.auxiliaries + 377] = v_668; + row[layout.auxiliaries + 378] = v_669; + row[layout.auxiliaries + 379] = v_670; + row[layout.auxiliaries + 380] = v_671; + row[layout.auxiliaries + 381] = v_672; + row[layout.auxiliaries + 382] = v_673; + row[layout.auxiliaries + 383] = v_674; + row[layout.auxiliaries + 384] = v_675; + row[layout.auxiliaries + 385] = v_676; + row[layout.auxiliaries + 386] = v_677; + row[layout.auxiliaries + 387] = v_678; + row[layout.auxiliaries + 388] = v_679; + row[layout.auxiliaries + 389] = v_680; + row[layout.auxiliaries + 390] = v_681; + row[layout.auxiliaries + 391] = v_682; + row[layout.auxiliaries + 392] = v_683; + row[layout.auxiliaries + 393] = v_684; + row[layout.auxiliaries + 394] = v_685; + row[layout.auxiliaries + 395] = v_686; + row[layout.auxiliaries + 396] = v_687; + row[layout.auxiliaries + 397] = v_688; + row[layout.auxiliaries + 398] = v_689; + row[layout.auxiliaries + 399] = v_690; + row[layout.auxiliaries + 400] = v_691; + row[layout.auxiliaries + 401] = v_692; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_83(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 176 : 1296; + const Seed_multi_stark_83 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_83(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_83(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_83<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_83<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_83(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 129 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 402) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 1296 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_83); +} + +__device__ __constant__ uint64_t inverse_100_0[] = {0ULL}; +template struct Seed_multi_stark_100 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 176); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u8(data + 276); + case 7: return load_u8(data + 277); + case 8: return load_u8(data + 278); + case 9: return load_u8(data + 279); + case 10: return load_u8(data + 280); + case 11: return load_u8(data + 281); + case 12: return load_u32(data + 180); + case 13: return load_u64(data + 40); + case 14: return load_u64(data + 48); + case 15: return load_u64(data + 56); + case 16: return load_u8(data + 282); + case 17: return load_u8(data + 283); + case 18: return load_u8(data + 284); + case 19: return load_u8(data + 285); + case 20: return load_u8(data + 286); + case 21: return load_u8(data + 287); + case 22: return load_u32(data + 184); + case 23: return load_u64(data + 64); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u64(data + 88); + case 27: return load_u64(data + 96); + case 28: return load_u8(data + 288); + case 29: return load_u8(data + 289); + case 30: return load_u8(data + 290); + case 31: return load_u8(data + 291); + case 32: return load_u32(data + 188); + case 33: return load_u64(data + 104); + case 34: return load_u64(data + 112); + case 35: return load_u64(data + 120); + case 36: return load_u8(data + 292); + case 37: return load_u8(data + 293); + case 38: return load_u8(data + 294); + case 39: return load_u8(data + 295); + case 40: return load_u8(data + 296); + case 41: return load_u8(data + 297); + case 42: return load_u32(data + 192); + case 43: return load_u64(data + 128); + case 44: return load_u32(data + 196); + case 45: return load_u64(data + 136); + case 46: return load_u32(data + 200); + case 47: return load_u32(data + 204); + case 48: return load_u32(data + 208); + case 49: return load_u64(data + 144); + case 50: return load_u32(data + 212); + case 51: return load_u32(data + 216); + case 52: return load_u32(data + 220); + case 53: return load_u64(data + 152); + case 54: return load_u32(data + 224); + case 55: return load_u32(data + 228); + case 56: return load_u32(data + 232); + case 57: return load_u64(data + 160); + case 58: return load_u32(data + 236); + case 59: return load_u32(data + 240); + case 60: return load_u64(data + 168); + case 61: return load_u32(data + 244); + case 62: return load_u32(data + 248); + case 63: return load_u32(data + 252); + case 64: return load_u32(data + 256); + case 65: return load_u32(data + 260); + case 66: return load_u32(data + 264); + case 67: return load_u32(data + 268); + case 68: return load_u32(data + 272); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_100(Seed_multi_stark_100 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + switch (v_1) { + case 0ULL: { + const uint64_t v_3 = seed.word(3); + row[layout.auxiliaries + 1] = v_3; + const uint64_t v_4 = seed.word(4); + row[layout.auxiliaries + 2] = v_4; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_100_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); + const uint64_t v_5 = seed.word(3); + const uint64_t v_6 = seed.word(4); + const uint64_t v_7 = seed.word(5); + const uint64_t v_8 = seed.word(6); + const uint64_t v_9 = seed.word(7); + const uint64_t v_10 = seed.word(8); + const uint64_t v_11 = seed.word(9); + const uint64_t v_12 = seed.word(10); + const uint64_t v_13 = seed.word(11); + const uint64_t v_14 = seed.word(12); + row[layout.auxiliaries + 2] = v_5; + row[layout.auxiliaries + 3] = v_6; + row[layout.auxiliaries + 4] = v_7; + row[layout.auxiliaries + 5] = v_8; + row[layout.auxiliaries + 6] = v_9; + row[layout.auxiliaries + 7] = v_10; + row[layout.auxiliaries + 8] = v_11; + row[layout.auxiliaries + 9] = v_12; + row[layout.auxiliaries + 10] = v_13; + row[layout.auxiliaries + 11] = v_14; + const uint64_t v_15 = seed.word(13); + const uint64_t v_16 = seed.word(14); + const uint64_t v_17 = seed.word(15); + const uint64_t v_18 = seed.word(16); + const uint64_t v_19 = seed.word(17); + const uint64_t v_20 = seed.word(18); + const uint64_t v_21 = seed.word(19); + const uint64_t v_22 = seed.word(20); + const uint64_t v_23 = seed.word(21); + const uint64_t v_24 = seed.word(22); + row[layout.auxiliaries + 12] = v_15; + row[layout.auxiliaries + 13] = v_16; + row[layout.auxiliaries + 14] = v_17; + row[layout.auxiliaries + 15] = v_18; + row[layout.auxiliaries + 16] = v_19; + row[layout.auxiliaries + 17] = v_20; + row[layout.auxiliaries + 18] = v_21; + row[layout.auxiliaries + 19] = v_22; + row[layout.auxiliaries + 20] = v_23; + row[layout.auxiliaries + 21] = v_24; + const uint64_t v_25 = seed.word(23); + const uint64_t v_26 = seed.word(24); + const uint64_t v_27 = seed.word(25); + const uint64_t v_28 = seed.word(26); + const uint64_t v_29 = seed.word(27); + const uint64_t v_30 = seed.word(28); + const uint64_t v_31 = seed.word(29); + const uint64_t v_32 = seed.word(30); + const uint64_t v_33 = seed.word(31); + const uint64_t v_34 = seed.word(32); + row[layout.auxiliaries + 22] = v_25; + row[layout.auxiliaries + 23] = v_26; + row[layout.auxiliaries + 24] = v_27; + row[layout.auxiliaries + 25] = v_28; + row[layout.auxiliaries + 26] = v_29; + row[layout.auxiliaries + 27] = v_30; + row[layout.auxiliaries + 28] = v_31; + row[layout.auxiliaries + 29] = v_32; + row[layout.auxiliaries + 30] = v_33; + row[layout.auxiliaries + 31] = v_34; + const uint64_t v_35 = seed.word(33); + const uint64_t v_36 = seed.word(34); + const uint64_t v_37 = seed.word(35); + const uint64_t v_38 = seed.word(36); + const uint64_t v_39 = seed.word(37); + const uint64_t v_40 = seed.word(38); + const uint64_t v_41 = seed.word(39); + const uint64_t v_42 = seed.word(40); + const uint64_t v_43 = seed.word(41); + const uint64_t v_44 = seed.word(42); + row[layout.auxiliaries + 32] = v_35; + row[layout.auxiliaries + 33] = v_36; + row[layout.auxiliaries + 34] = v_37; + row[layout.auxiliaries + 35] = v_38; + row[layout.auxiliaries + 36] = v_39; + row[layout.auxiliaries + 37] = v_40; + row[layout.auxiliaries + 38] = v_41; + row[layout.auxiliaries + 39] = v_42; + row[layout.auxiliaries + 40] = v_43; + row[layout.auxiliaries + 41] = v_44; + const uint64_t v_45 = seed.word(43); + const uint64_t v_46 = seed.word(44); + row[layout.auxiliaries + 42] = v_45; + row[layout.auxiliaries + 43] = v_46; + const uint64_t v_47 = seed.word(45); + const uint64_t v_48 = seed.word(46); + row[layout.auxiliaries + 44] = v_47; + row[layout.auxiliaries + 45] = v_48; + const uint64_t v_50 = seed.word(47); + const uint64_t v_51 = seed.word(48); + row[layout.auxiliaries + 46] = v_50; + row[layout.auxiliaries + 47] = v_51; + const uint64_t v_52 = seed.word(49); + const uint64_t v_53 = seed.word(50); + row[layout.auxiliaries + 48] = v_52; + row[layout.auxiliaries + 49] = v_53; + const uint64_t v_54 = seed.word(51); + const uint64_t v_55 = seed.word(52); + row[layout.auxiliaries + 50] = v_54; + row[layout.auxiliaries + 51] = v_55; + const uint64_t v_56 = seed.word(53); + const uint64_t v_57 = seed.word(54); + row[layout.auxiliaries + 52] = v_56; + row[layout.auxiliaries + 53] = v_57; + const uint64_t v_58 = seed.word(55); + const uint64_t v_59 = seed.word(56); + row[layout.auxiliaries + 54] = v_58; + row[layout.auxiliaries + 55] = v_59; + const uint64_t v_60 = seed.word(57); + row[layout.auxiliaries + 56] = v_60; + const uint64_t v_61 = uint64_t(v_60 == 0); + row[layout.auxiliaries + 57] = inverse(v_60); + row[layout.auxiliaries + 58] = v_61; + const uint64_t v_62 = goldilocks_add(v_60, v_61); + const uint64_t v_63 = goldilocks_add(v_62, v_62); + const uint64_t v_64 = goldilocks_add(v_52, v_63); + const uint64_t v_65 = ((v_64 >> 0) & 255ULL); + const uint64_t v_66 = ((v_64 >> 8) & 255ULL); + const uint64_t v_67 = ((v_64 >> 16) & 255ULL); + const uint64_t v_68 = ((v_64 >> 24) & 255ULL); + const uint64_t v_69 = ((v_64 >> 32) & 255ULL); + const uint64_t v_70 = ((v_64 >> 40) & 255ULL); + const uint64_t v_71 = ((v_64 >> 48) & 255ULL); + const uint64_t v_72 = ((v_64 >> 56) & 255ULL); + row[layout.auxiliaries + 59] = v_65; + row[layout.auxiliaries + 60] = v_66; + row[layout.auxiliaries + 61] = v_67; + row[layout.auxiliaries + 62] = v_68; + row[layout.auxiliaries + 63] = v_69; + row[layout.auxiliaries + 64] = v_70; + row[layout.auxiliaries + 65] = v_71; + row[layout.auxiliaries + 66] = v_72; + const uint64_t v_94 = 1020ULL; + const uint64_t v_95 = goldilocks_sub(v_72, v_94); + const uint64_t v_96 = goldilocks_add(v_71, v_95); + const uint64_t v_97 = goldilocks_add(v_70, v_96); + const uint64_t v_98 = goldilocks_add(v_69, v_97); + const uint64_t v_99 = uint64_t(v_98 == 0); + row[layout.auxiliaries + 67] = inverse(v_98); + row[layout.auxiliaries + 68] = v_99; + const uint64_t v_100 = goldilocks_add(v_67, v_68); + const uint64_t v_101 = goldilocks_add(v_66, v_100); + const uint64_t v_102 = goldilocks_add(v_65, v_101); + const uint64_t v_103 = uint64_t(v_102 == 0); + row[layout.auxiliaries + 69] = inverse(v_102); + row[layout.auxiliaries + 70] = v_103; + const uint64_t v_104 = 1ULL; + const uint64_t v_105 = goldilocks_sub(v_104, v_103); + const uint64_t v_106 = goldilocks_mul(v_99, v_105); + row[layout.auxiliaries + 71] = v_106; + const uint64_t v_108 = ((v_63 >> 0) & 255ULL); + const uint64_t v_109 = ((v_63 >> 8) & 255ULL); + const uint64_t v_110 = ((v_63 >> 16) & 255ULL); + const uint64_t v_111 = ((v_63 >> 24) & 255ULL); + const uint64_t v_112 = ((v_63 >> 32) & 255ULL); + const uint64_t v_113 = ((v_63 >> 40) & 255ULL); + const uint64_t v_114 = ((v_63 >> 48) & 255ULL); + const uint64_t v_115 = ((v_63 >> 56) & 255ULL); + row[layout.auxiliaries + 72] = v_108; + row[layout.auxiliaries + 73] = v_109; + row[layout.auxiliaries + 74] = v_110; + row[layout.auxiliaries + 75] = v_111; + row[layout.auxiliaries + 76] = v_112; + row[layout.auxiliaries + 77] = v_113; + row[layout.auxiliaries + 78] = v_114; + row[layout.auxiliaries + 79] = v_115; + const uint64_t v_130 = goldilocks_sub(v_115, v_94); + const uint64_t v_131 = goldilocks_add(v_114, v_130); + const uint64_t v_132 = goldilocks_add(v_113, v_131); + const uint64_t v_133 = goldilocks_add(v_112, v_132); + const uint64_t v_134 = uint64_t(v_133 == 0); + row[layout.auxiliaries + 80] = inverse(v_133); + row[layout.auxiliaries + 81] = v_134; + const uint64_t v_135 = goldilocks_add(v_110, v_111); + const uint64_t v_136 = goldilocks_add(v_109, v_135); + const uint64_t v_137 = goldilocks_add(v_108, v_136); + const uint64_t v_138 = uint64_t(v_137 == 0); + row[layout.auxiliaries + 82] = inverse(v_137); + row[layout.auxiliaries + 83] = v_138; + const uint64_t v_139 = goldilocks_sub(v_104, v_138); + const uint64_t v_140 = goldilocks_mul(v_134, v_139); + row[layout.auxiliaries + 84] = v_140; + const uint64_t v_142 = ((v_45 >> 0) & 255ULL); + const uint64_t v_143 = ((v_45 >> 8) & 255ULL); + const uint64_t v_144 = ((v_45 >> 16) & 255ULL); + const uint64_t v_145 = ((v_45 >> 24) & 255ULL); + const uint64_t v_146 = ((v_45 >> 32) & 255ULL); + const uint64_t v_147 = ((v_45 >> 40) & 255ULL); + const uint64_t v_148 = ((v_45 >> 48) & 255ULL); + const uint64_t v_149 = ((v_45 >> 56) & 255ULL); + row[layout.auxiliaries + 85] = v_142; + row[layout.auxiliaries + 86] = v_143; + row[layout.auxiliaries + 87] = v_144; + row[layout.auxiliaries + 88] = v_145; + row[layout.auxiliaries + 89] = v_146; + row[layout.auxiliaries + 90] = v_147; + row[layout.auxiliaries + 91] = v_148; + row[layout.auxiliaries + 92] = v_149; + const uint64_t v_164 = goldilocks_sub(v_149, v_94); + const uint64_t v_165 = goldilocks_add(v_148, v_164); + const uint64_t v_166 = goldilocks_add(v_147, v_165); + const uint64_t v_167 = goldilocks_add(v_146, v_166); + const uint64_t v_168 = uint64_t(v_167 == 0); + row[layout.auxiliaries + 93] = inverse(v_167); + row[layout.auxiliaries + 94] = v_168; + const uint64_t v_169 = goldilocks_add(v_144, v_145); + const uint64_t v_170 = goldilocks_add(v_143, v_169); + const uint64_t v_171 = goldilocks_add(v_142, v_170); + const uint64_t v_172 = uint64_t(v_171 == 0); + row[layout.auxiliaries + 95] = inverse(v_171); + row[layout.auxiliaries + 96] = v_172; + const uint64_t v_173 = goldilocks_sub(v_104, v_172); + const uint64_t v_174 = goldilocks_mul(v_168, v_173); + row[layout.auxiliaries + 97] = v_174; + const uint64_t v_177 = seed.word(58); + const uint64_t v_178 = seed.word(59); + const uint64_t v_179 = seed.word(60); + row[layout.auxiliaries + 98] = v_177; + row[layout.auxiliaries + 99] = v_178; + row[layout.auxiliaries + 100] = v_179; + const uint64_t v_180 = seed.word(61); + row[layout.auxiliaries + 101] = v_180; + const uint64_t v_181 = seed.word(62); + row[layout.auxiliaries + 102] = v_181; + const uint64_t v_182 = seed.word(63); + row[layout.auxiliaries + 103] = v_182; + const uint64_t v_183 = seed.word(64); + row[layout.auxiliaries + 104] = v_183; + const uint64_t v_184 = seed.word(65); + row[layout.auxiliaries + 105] = v_184; + const uint64_t v_185 = seed.word(66); + row[layout.auxiliaries + 106] = v_185; + const uint64_t v_186 = seed.word(67); + row[layout.auxiliaries + 107] = v_186; + const uint64_t v_187 = seed.word(68); + row[layout.auxiliaries + 108] = v_187; + row[layout.selectors + 1] = 1; + return 0; + } + } +} +template __global__ void kernel_multi_stark_100(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 304 : 552; + const Seed_multi_stark_100 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_100(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_100(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_100<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_100<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_100(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 109) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 304 : encoding == 0 ? 552 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_100); +} + +__device__ __constant__ uint64_t inverse_114_0[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_1[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_2[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_3[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_4[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_5[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_6[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_7[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_8[] = {0ULL}; +__device__ __constant__ uint64_t inverse_114_10[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_114_11[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_114_12[] = {18446744069414584320ULL, 0ULL}; +__device__ __constant__ uint64_t inverse_114_13[] = {18446744069414584320ULL, 0ULL}; +template struct Seed_multi_stark_114 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 312); + case 2: return load_u32(data + 316); + case 3: return load_u64(data + 8); + case 4: return load_u32(data + 320); + case 5: return load_u32(data + 324); + case 6: return load_u64(data + 16); + case 7: return load_u8(data + 404); + case 8: return load_u8(data + 405); + case 9: return load_u8(data + 406); + case 10: return load_u8(data + 407); + case 11: return load_u8(data + 408); + case 12: return load_u8(data + 409); + case 13: return load_u8(data + 410); + case 14: return load_u8(data + 411); + case 15: return load_u32(data + 328); + case 16: return load_u32(data + 332); + case 17: return load_u8(data + 412); + case 18: return load_u64(data + 24); + case 19: return load_u64(data + 32); + case 20: return load_u64(data + 40); + case 21: return load_u64(data + 48); + case 22: return load_u64(data + 56); + case 23: return load_u64(data + 64); + case 24: return load_u64(data + 72); + case 25: return load_u64(data + 80); + case 26: return load_u32(data + 336); + case 27: return load_u32(data + 340); + case 28: return load_u8(data + 413); + case 29: return load_u8(data + 414); + case 30: return load_u8(data + 415); + case 31: return load_u8(data + 416); + case 32: return load_u8(data + 417); + case 33: return load_u8(data + 418); + case 34: return load_u8(data + 419); + case 35: return load_u8(data + 420); + case 36: return load_u8(data + 421); + case 37: return load_u32(data + 344); + case 38: return load_u32(data + 348); + case 39: return load_u8(data + 422); + case 40: return load_u8(data + 423); + case 41: return load_u8(data + 424); + case 42: return load_u8(data + 425); + case 43: return load_u8(data + 426); + case 44: return load_u8(data + 427); + case 45: return load_u8(data + 428); + case 46: return load_u8(data + 429); + case 47: return load_u8(data + 430); + case 48: return load_u32(data + 352); + case 49: return load_u32(data + 356); + case 50: return load_u8(data + 431); + case 51: return load_u8(data + 432); + case 52: return load_u8(data + 433); + case 53: return load_u8(data + 434); + case 54: return load_u8(data + 435); + case 55: return load_u8(data + 436); + case 56: return load_u8(data + 437); + case 57: return load_u8(data + 438); + case 58: return load_u8(data + 439); + case 59: return load_u32(data + 360); + case 60: return load_u32(data + 364); + case 61: return load_u8(data + 440); + case 62: return load_u8(data + 441); + case 63: return load_u8(data + 442); + case 64: return load_u8(data + 443); + case 65: return load_u8(data + 444); + case 66: return load_u8(data + 445); + case 67: return load_u8(data + 446); + case 68: return load_u8(data + 447); + case 69: return load_u8(data + 448); + case 70: return load_u32(data + 368); + case 71: return load_u32(data + 372); + case 72: return load_u8(data + 449); + case 73: return load_u8(data + 450); + case 74: return load_u8(data + 451); + case 75: return load_u8(data + 452); + case 76: return load_u8(data + 453); + case 77: return load_u8(data + 454); + case 78: return load_u8(data + 455); + case 79: return load_u8(data + 456); + case 80: return load_u8(data + 457); + case 81: return load_u32(data + 376); + case 82: return load_u32(data + 380); + case 83: return load_u8(data + 458); + case 84: return load_u8(data + 459); + case 85: return load_u8(data + 460); + case 86: return load_u8(data + 461); + case 87: return load_u8(data + 462); + case 88: return load_u8(data + 463); + case 89: return load_u8(data + 464); + case 90: return load_u8(data + 465); + case 91: return load_u8(data + 466); + case 92: return load_u32(data + 384); + case 93: return load_u32(data + 388); + case 94: return load_u8(data + 467); + case 95: return load_u8(data + 468); + case 96: return load_u64(data + 88); + case 97: return load_u64(data + 96); + case 98: return load_u64(data + 104); + case 99: return load_u64(data + 112); + case 100: return load_u64(data + 120); + case 101: return load_u64(data + 128); + case 102: return load_u64(data + 136); + case 103: return load_u64(data + 144); + case 104: return load_u64(data + 152); + case 105: return load_u8(data + 469); + case 106: return load_u64(data + 160); + case 107: return load_u64(data + 168); + case 108: return load_u8(data + 470); + case 109: return load_u8(data + 471); + case 110: return load_u8(data + 472); + case 111: return load_u8(data + 473); + case 112: return load_u8(data + 474); + case 113: return load_u8(data + 475); + case 114: return load_u8(data + 476); + case 115: return load_u8(data + 477); + case 116: return load_u8(data + 478); + case 117: return load_u8(data + 479); + case 118: return load_u8(data + 480); + case 119: return load_u8(data + 481); + case 120: return load_u8(data + 482); + case 121: return load_u8(data + 483); + case 122: return load_u8(data + 484); + case 123: return load_u8(data + 485); + case 124: return load_u8(data + 486); + case 125: return load_u8(data + 487); + case 126: return load_u8(data + 488); + case 127: return load_u8(data + 489); + case 128: return load_u8(data + 490); + case 129: return load_u8(data + 491); + case 130: return load_u8(data + 492); + case 131: return load_u8(data + 493); + case 132: return load_u8(data + 494); + case 133: return load_u8(data + 495); + case 134: return load_u8(data + 496); + case 135: return load_u8(data + 497); + case 136: return load_u8(data + 498); + case 137: return load_u8(data + 499); + case 138: return load_u8(data + 500); + case 139: return load_u8(data + 501); + case 140: return load_u8(data + 502); + case 141: return load_u8(data + 503); + case 142: return load_u8(data + 504); + case 143: return load_u8(data + 505); + case 144: return load_u8(data + 506); + case 145: return load_u8(data + 507); + case 146: return load_u8(data + 508); + case 147: return load_u8(data + 509); + case 148: return load_u8(data + 510); + case 149: return load_u8(data + 511); + case 150: return load_u8(data + 512); + case 151: return load_u8(data + 513); + case 152: return load_u8(data + 514); + case 153: return load_u8(data + 515); + case 154: return load_u8(data + 516); + case 155: return load_u8(data + 517); + case 156: return load_u8(data + 518); + case 157: return load_u8(data + 519); + case 158: return load_u8(data + 520); + case 159: return load_u8(data + 521); + case 160: return load_u8(data + 522); + case 161: return load_u8(data + 523); + case 162: return load_u8(data + 524); + case 163: return load_u8(data + 525); + case 164: return load_u8(data + 526); + case 165: return load_u8(data + 527); + case 166: return load_u8(data + 528); + case 167: return load_u8(data + 529); + case 168: return load_u8(data + 530); + case 169: return load_u8(data + 531); + case 170: return load_u8(data + 532); + case 171: return load_u8(data + 533); + case 172: return load_u8(data + 534); + case 173: return load_u8(data + 535); + case 174: return load_u8(data + 536); + case 175: return load_u8(data + 537); + case 176: return load_u8(data + 538); + case 177: return load_u8(data + 539); + case 178: return load_u8(data + 540); + case 179: return load_u8(data + 541); + case 180: return load_u8(data + 542); + case 181: return load_u64(data + 176); + case 182: return load_u64(data + 184); + case 183: return load_u64(data + 192); + case 184: return load_u64(data + 200); + case 185: return load_u64(data + 208); + case 186: return load_u64(data + 216); + case 187: return load_u64(data + 224); + case 188: return load_u64(data + 232); + case 189: return load_u64(data + 240); + case 190: return load_u64(data + 248); + case 191: return load_u64(data + 256); + case 192: return load_u64(data + 264); + case 193: return load_u64(data + 272); + case 194: return load_u64(data + 280); + case 195: return load_u64(data + 288); + case 196: return load_u64(data + 296); + case 197: return load_u32(data + 392); + case 198: return load_u32(data + 396); + case 199: return load_u32(data + 400); + case 200: return load_u64(data + 304); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_114(Seed_multi_stark_114 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + const uint64_t v_8 = seed.word(9); + const uint64_t v_9 = seed.word(10); + const uint64_t v_10 = seed.word(11); + const uint64_t v_11 = seed.word(12); + const uint64_t v_12 = seed.word(13); + const uint64_t v_13 = seed.word(14); + const uint64_t v_14 = seed.word(15); + const uint64_t v_15 = seed.word(16); + const uint64_t v_16 = seed.word(17); + row[layout.auxiliaries + 1] = v_6; + row[layout.auxiliaries + 2] = v_7; + row[layout.auxiliaries + 3] = v_8; + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + row[layout.auxiliaries + 7] = v_12; + row[layout.auxiliaries + 8] = v_13; + row[layout.auxiliaries + 9] = v_14; + row[layout.auxiliaries + 10] = v_15; + row[layout.auxiliaries + 11] = v_16; + switch (v_16) { + case 0ULL: { + const uint64_t v_17 = seed.word(18); + const uint64_t v_18 = seed.word(19); + const uint64_t v_19 = seed.word(20); + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + row[layout.auxiliaries + 12] = v_17; + row[layout.auxiliaries + 13] = v_18; + row[layout.auxiliaries + 14] = v_19; + row[layout.auxiliaries + 15] = v_20; + row[layout.auxiliaries + 16] = v_21; + row[layout.auxiliaries + 17] = v_22; + row[layout.auxiliaries + 18] = v_23; + row[layout.auxiliaries + 19] = v_24; + switch (v_17) { + case 0ULL: { + switch (v_18) { + case 0ULL: { + switch (v_19) { + case 0ULL: { + switch (v_20) { + case 0ULL: { + switch (v_21) { + case 0ULL: { + switch (v_22) { + case 0ULL: { + switch (v_23) { + case 0ULL: { + switch (v_24) { + case 0ULL: { + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + const uint64_t v_31 = seed.word(32); + const uint64_t v_32 = seed.word(33); + const uint64_t v_33 = seed.word(34); + const uint64_t v_34 = seed.word(35); + const uint64_t v_35 = seed.word(36); + const uint64_t v_36 = seed.word(37); + const uint64_t v_37 = seed.word(38); + const uint64_t v_38 = seed.word(39); + const uint64_t v_39 = seed.word(40); + const uint64_t v_40 = seed.word(41); + const uint64_t v_41 = seed.word(42); + const uint64_t v_42 = seed.word(43); + const uint64_t v_43 = seed.word(44); + const uint64_t v_44 = seed.word(45); + const uint64_t v_45 = seed.word(46); + const uint64_t v_46 = seed.word(47); + const uint64_t v_47 = seed.word(48); + const uint64_t v_48 = seed.word(49); + const uint64_t v_49 = seed.word(50); + const uint64_t v_50 = seed.word(51); + const uint64_t v_51 = seed.word(52); + const uint64_t v_52 = seed.word(53); + const uint64_t v_53 = seed.word(54); + const uint64_t v_54 = seed.word(55); + const uint64_t v_55 = seed.word(56); + const uint64_t v_56 = seed.word(57); + row[layout.auxiliaries + 20] = v_25; + row[layout.auxiliaries + 21] = v_26; + row[layout.auxiliaries + 22] = v_27; + row[layout.auxiliaries + 23] = v_28; + row[layout.auxiliaries + 24] = v_29; + row[layout.auxiliaries + 25] = v_30; + row[layout.auxiliaries + 26] = v_31; + row[layout.auxiliaries + 27] = v_32; + row[layout.auxiliaries + 28] = v_33; + row[layout.auxiliaries + 29] = v_34; + row[layout.auxiliaries + 30] = v_35; + row[layout.auxiliaries + 31] = v_36; + row[layout.auxiliaries + 32] = v_37; + row[layout.auxiliaries + 33] = v_38; + row[layout.auxiliaries + 34] = v_39; + row[layout.auxiliaries + 35] = v_40; + row[layout.auxiliaries + 36] = v_41; + row[layout.auxiliaries + 37] = v_42; + row[layout.auxiliaries + 38] = v_43; + row[layout.auxiliaries + 39] = v_44; + row[layout.auxiliaries + 40] = v_45; + row[layout.auxiliaries + 41] = v_46; + row[layout.auxiliaries + 42] = v_47; + row[layout.auxiliaries + 43] = v_48; + row[layout.auxiliaries + 44] = v_49; + row[layout.auxiliaries + 45] = v_50; + row[layout.auxiliaries + 46] = v_51; + row[layout.auxiliaries + 47] = v_52; + row[layout.auxiliaries + 48] = v_53; + row[layout.auxiliaries + 49] = v_54; + row[layout.auxiliaries + 50] = v_55; + row[layout.auxiliaries + 51] = v_56; + const uint64_t v_58 = seed.word(58); + const uint64_t v_59 = seed.word(59); + const uint64_t v_60 = seed.word(60); + const uint64_t v_61 = seed.word(61); + const uint64_t v_62 = seed.word(62); + const uint64_t v_63 = seed.word(63); + const uint64_t v_64 = seed.word(64); + const uint64_t v_65 = seed.word(65); + row[layout.auxiliaries + 52] = v_58; + row[layout.auxiliaries + 53] = v_59; + row[layout.auxiliaries + 54] = v_60; + row[layout.auxiliaries + 55] = v_61; + row[layout.auxiliaries + 56] = v_62; + row[layout.auxiliaries + 57] = v_63; + row[layout.auxiliaries + 58] = v_64; + row[layout.auxiliaries + 59] = v_65; + const uint64_t v_82 = seed.word(66); + const uint64_t v_83 = seed.word(67); + const uint64_t v_84 = seed.word(68); + const uint64_t v_85 = seed.word(69); + const uint64_t v_86 = seed.word(70); + const uint64_t v_87 = seed.word(71); + const uint64_t v_88 = seed.word(72); + const uint64_t v_89 = seed.word(73); + const uint64_t v_90 = seed.word(74); + const uint64_t v_91 = seed.word(75); + const uint64_t v_92 = seed.word(76); + const uint64_t v_93 = seed.word(77); + const uint64_t v_94 = seed.word(78); + const uint64_t v_95 = seed.word(79); + const uint64_t v_96 = seed.word(80); + const uint64_t v_97 = seed.word(81); + const uint64_t v_98 = seed.word(82); + const uint64_t v_99 = seed.word(83); + const uint64_t v_100 = seed.word(84); + const uint64_t v_101 = seed.word(85); + const uint64_t v_102 = seed.word(86); + const uint64_t v_103 = seed.word(87); + const uint64_t v_104 = seed.word(88); + const uint64_t v_105 = seed.word(89); + const uint64_t v_106 = seed.word(90); + const uint64_t v_107 = seed.word(91); + const uint64_t v_108 = seed.word(92); + const uint64_t v_109 = seed.word(93); + const uint64_t v_110 = seed.word(94); + const uint64_t v_111 = seed.word(95); + const uint64_t v_112 = seed.word(96); + const uint64_t v_113 = seed.word(97); + row[layout.auxiliaries + 60] = v_82; + row[layout.auxiliaries + 61] = v_83; + row[layout.auxiliaries + 62] = v_84; + row[layout.auxiliaries + 63] = v_85; + row[layout.auxiliaries + 64] = v_86; + row[layout.auxiliaries + 65] = v_87; + row[layout.auxiliaries + 66] = v_88; + row[layout.auxiliaries + 67] = v_89; + row[layout.auxiliaries + 68] = v_90; + row[layout.auxiliaries + 69] = v_91; + row[layout.auxiliaries + 70] = v_92; + row[layout.auxiliaries + 71] = v_93; + row[layout.auxiliaries + 72] = v_94; + row[layout.auxiliaries + 73] = v_95; + row[layout.auxiliaries + 74] = v_96; + row[layout.auxiliaries + 75] = v_97; + row[layout.auxiliaries + 76] = v_98; + row[layout.auxiliaries + 77] = v_99; + row[layout.auxiliaries + 78] = v_100; + row[layout.auxiliaries + 79] = v_101; + row[layout.auxiliaries + 80] = v_102; + row[layout.auxiliaries + 81] = v_103; + row[layout.auxiliaries + 82] = v_104; + row[layout.auxiliaries + 83] = v_105; + row[layout.auxiliaries + 84] = v_106; + row[layout.auxiliaries + 85] = v_107; + row[layout.auxiliaries + 86] = v_108; + row[layout.auxiliaries + 87] = v_109; + row[layout.auxiliaries + 88] = v_110; + row[layout.auxiliaries + 89] = v_111; + row[layout.auxiliaries + 90] = v_112; + row[layout.auxiliaries + 91] = v_113; + const uint64_t v_114 = seed.word(98); + row[layout.auxiliaries + 92] = v_114; + row[layout.selectors + 0] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 20] = (v_24 <= 0ULL ? inverse_114_0[v_24] : inverse(goldilocks_sub(v_24, 0ULL))); + row[layout.selectors + 1] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_23 <= 0ULL ? inverse_114_1[v_23] : inverse(goldilocks_sub(v_23, 0ULL))); + row[layout.selectors + 2] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_22 <= 0ULL ? inverse_114_2[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); + row[layout.selectors + 3] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_21 <= 0ULL ? inverse_114_3[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); + row[layout.selectors + 4] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_20 <= 0ULL ? inverse_114_4[v_20] : inverse(goldilocks_sub(v_20, 0ULL))); + row[layout.selectors + 5] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_19 <= 0ULL ? inverse_114_5[v_19] : inverse(goldilocks_sub(v_19, 0ULL))); + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_18 <= 0ULL ? inverse_114_6[v_18] : inverse(goldilocks_sub(v_18, 0ULL))); + row[layout.selectors + 7] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 20] = (v_17 <= 0ULL ? inverse_114_7[v_17] : inverse(goldilocks_sub(v_17, 0ULL))); + row[layout.selectors + 8] = 1; + return 0; + } + } + } + default: { + row[layout.auxiliaries + 12] = (v_16 <= 0ULL ? inverse_114_8[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); + const uint64_t v_115 = seed.word(18); + const uint64_t v_116 = seed.word(19); + const uint64_t v_117 = seed.word(20); + const uint64_t v_118 = seed.word(21); + const uint64_t v_119 = seed.word(22); + const uint64_t v_120 = seed.word(23); + const uint64_t v_121 = seed.word(24); + const uint64_t v_122 = seed.word(25); + const uint64_t v_123 = seed.word(26); + const uint64_t v_124 = seed.word(27); + const uint64_t v_125 = seed.word(28); + row[layout.auxiliaries + 13] = v_115; + row[layout.auxiliaries + 14] = v_116; + row[layout.auxiliaries + 15] = v_117; + row[layout.auxiliaries + 16] = v_118; + row[layout.auxiliaries + 17] = v_119; + row[layout.auxiliaries + 18] = v_120; + row[layout.auxiliaries + 19] = v_121; + row[layout.auxiliaries + 20] = v_122; + row[layout.auxiliaries + 21] = v_123; + row[layout.auxiliaries + 22] = v_124; + row[layout.auxiliaries + 23] = v_125; + const uint64_t v_126 = seed.word(29); + const uint64_t v_127 = seed.word(30); + const uint64_t v_128 = seed.word(31); + const uint64_t v_129 = seed.word(32); + const uint64_t v_130 = seed.word(33); + const uint64_t v_131 = seed.word(34); + const uint64_t v_132 = seed.word(35); + const uint64_t v_133 = seed.word(36); + const uint64_t v_134 = seed.word(37); + const uint64_t v_135 = seed.word(38); + const uint64_t v_136 = seed.word(39); + row[layout.auxiliaries + 24] = v_126; + row[layout.auxiliaries + 25] = v_127; + row[layout.auxiliaries + 26] = v_128; + row[layout.auxiliaries + 27] = v_129; + row[layout.auxiliaries + 28] = v_130; + row[layout.auxiliaries + 29] = v_131; + row[layout.auxiliaries + 30] = v_132; + row[layout.auxiliaries + 31] = v_133; + row[layout.auxiliaries + 32] = v_134; + row[layout.auxiliaries + 33] = v_135; + row[layout.auxiliaries + 34] = v_136; + const uint64_t v_137 = seed.word(40); + const uint64_t v_138 = seed.word(41); + const uint64_t v_139 = seed.word(42); + const uint64_t v_140 = seed.word(43); + const uint64_t v_141 = seed.word(44); + const uint64_t v_142 = seed.word(45); + const uint64_t v_143 = seed.word(46); + const uint64_t v_144 = seed.word(47); + const uint64_t v_145 = seed.word(48); + const uint64_t v_146 = seed.word(49); + const uint64_t v_147 = seed.word(50); + row[layout.auxiliaries + 35] = v_137; + row[layout.auxiliaries + 36] = v_138; + row[layout.auxiliaries + 37] = v_139; + row[layout.auxiliaries + 38] = v_140; + row[layout.auxiliaries + 39] = v_141; + row[layout.auxiliaries + 40] = v_142; + row[layout.auxiliaries + 41] = v_143; + row[layout.auxiliaries + 42] = v_144; + row[layout.auxiliaries + 43] = v_145; + row[layout.auxiliaries + 44] = v_146; + row[layout.auxiliaries + 45] = v_147; + const uint64_t v_148 = seed.word(51); + const uint64_t v_149 = seed.word(52); + const uint64_t v_150 = seed.word(53); + const uint64_t v_151 = seed.word(54); + const uint64_t v_152 = seed.word(55); + const uint64_t v_153 = seed.word(56); + const uint64_t v_154 = seed.word(57); + const uint64_t v_155 = seed.word(58); + const uint64_t v_156 = seed.word(59); + const uint64_t v_157 = seed.word(60); + const uint64_t v_158 = seed.word(61); + row[layout.auxiliaries + 46] = v_148; + row[layout.auxiliaries + 47] = v_149; + row[layout.auxiliaries + 48] = v_150; + row[layout.auxiliaries + 49] = v_151; + row[layout.auxiliaries + 50] = v_152; + row[layout.auxiliaries + 51] = v_153; + row[layout.auxiliaries + 52] = v_154; + row[layout.auxiliaries + 53] = v_155; + row[layout.auxiliaries + 54] = v_156; + row[layout.auxiliaries + 55] = v_157; + row[layout.auxiliaries + 56] = v_158; + const uint64_t v_159 = seed.word(62); + const uint64_t v_160 = seed.word(63); + const uint64_t v_161 = seed.word(64); + const uint64_t v_162 = seed.word(65); + const uint64_t v_163 = seed.word(66); + const uint64_t v_164 = seed.word(67); + const uint64_t v_165 = seed.word(68); + const uint64_t v_166 = seed.word(69); + const uint64_t v_167 = seed.word(70); + const uint64_t v_168 = seed.word(71); + const uint64_t v_169 = seed.word(72); + row[layout.auxiliaries + 57] = v_159; + row[layout.auxiliaries + 58] = v_160; + row[layout.auxiliaries + 59] = v_161; + row[layout.auxiliaries + 60] = v_162; + row[layout.auxiliaries + 61] = v_163; + row[layout.auxiliaries + 62] = v_164; + row[layout.auxiliaries + 63] = v_165; + row[layout.auxiliaries + 64] = v_166; + row[layout.auxiliaries + 65] = v_167; + row[layout.auxiliaries + 66] = v_168; + row[layout.auxiliaries + 67] = v_169; + const uint64_t v_170 = seed.word(73); + const uint64_t v_171 = seed.word(74); + const uint64_t v_172 = seed.word(75); + const uint64_t v_173 = seed.word(76); + const uint64_t v_174 = seed.word(77); + const uint64_t v_175 = seed.word(78); + const uint64_t v_176 = seed.word(79); + const uint64_t v_177 = seed.word(80); + const uint64_t v_178 = seed.word(81); + const uint64_t v_179 = seed.word(82); + const uint64_t v_180 = seed.word(83); + row[layout.auxiliaries + 68] = v_170; + row[layout.auxiliaries + 69] = v_171; + row[layout.auxiliaries + 70] = v_172; + row[layout.auxiliaries + 71] = v_173; + row[layout.auxiliaries + 72] = v_174; + row[layout.auxiliaries + 73] = v_175; + row[layout.auxiliaries + 74] = v_176; + row[layout.auxiliaries + 75] = v_177; + row[layout.auxiliaries + 76] = v_178; + row[layout.auxiliaries + 77] = v_179; + row[layout.auxiliaries + 78] = v_180; + const uint64_t v_181 = seed.word(84); + const uint64_t v_182 = seed.word(85); + const uint64_t v_183 = seed.word(86); + const uint64_t v_184 = seed.word(87); + const uint64_t v_185 = seed.word(88); + const uint64_t v_186 = seed.word(89); + const uint64_t v_187 = seed.word(90); + const uint64_t v_188 = seed.word(91); + const uint64_t v_189 = seed.word(92); + const uint64_t v_190 = seed.word(93); + const uint64_t v_191 = seed.word(94); + row[layout.auxiliaries + 79] = v_181; + row[layout.auxiliaries + 80] = v_182; + row[layout.auxiliaries + 81] = v_183; + row[layout.auxiliaries + 82] = v_184; + row[layout.auxiliaries + 83] = v_185; + row[layout.auxiliaries + 84] = v_186; + row[layout.auxiliaries + 85] = v_187; + row[layout.auxiliaries + 86] = v_188; + row[layout.auxiliaries + 87] = v_189; + row[layout.auxiliaries + 88] = v_190; + row[layout.auxiliaries + 89] = v_191; + const uint64_t v_201 = seed.word(95); + const uint64_t v_202 = seed.word(96); + const uint64_t v_203 = seed.word(97); + const uint64_t v_204 = seed.word(98); + const uint64_t v_205 = seed.word(99); + const uint64_t v_206 = seed.word(100); + const uint64_t v_207 = seed.word(101); + const uint64_t v_208 = seed.word(102); + const uint64_t v_209 = seed.word(103); + const uint64_t v_210 = seed.word(104); + row[layout.auxiliaries + 90] = v_201; + row[layout.auxiliaries + 91] = v_202; + row[layout.auxiliaries + 92] = v_203; + row[layout.auxiliaries + 93] = v_204; + row[layout.auxiliaries + 94] = v_205; + row[layout.auxiliaries + 95] = v_206; + row[layout.auxiliaries + 96] = v_207; + row[layout.auxiliaries + 97] = v_208; + row[layout.auxiliaries + 98] = v_209; + row[layout.auxiliaries + 99] = v_210; + uint64_t v_217; + switch (v_201) { + case 1ULL: { + const uint64_t v_211 = seed.word(105); + const uint64_t v_212 = seed.word(106); + const uint64_t v_213 = seed.word(107); + row[layout.auxiliaries + 100] = v_211; + row[layout.auxiliaries + 101] = v_212; + row[layout.auxiliaries + 102] = v_213; + switch (v_211) { + case 1ULL: { + const uint64_t v_214 = 1ULL; + row[layout.selectors + 9] = 1; + v_217 = v_214; + goto continuation_9; + } + default: { + row[layout.auxiliaries + 103] = (v_211 <= 1ULL ? inverse_114_10[v_211] : inverse(goldilocks_sub(v_211, 1ULL))); + const uint64_t v_215 = 0ULL; + row[layout.selectors + 10] = 1; + v_217 = v_215; + goto continuation_9; + } + } + } + default: { + row[layout.auxiliaries + 100] = (v_201 <= 1ULL ? inverse_114_11[v_201] : inverse(goldilocks_sub(v_201, 1ULL))); + const uint64_t v_216 = 0ULL; + row[layout.selectors + 11] = 1; + v_217 = v_216; + goto continuation_9; + } + } + continuation_9:; + row[layout.auxiliaries + 104] = v_217; + const uint64_t v_218 = 15ULL; + const uint64_t v_219 = goldilocks_sub(v_2, v_218); + const uint64_t v_220 = uint64_t(v_219 == 0); + row[layout.auxiliaries + 105] = inverse(v_219); + row[layout.auxiliaries + 106] = v_220; + const uint64_t v_221 = uint64_t(v_2 == 0); + row[layout.auxiliaries + 107] = inverse(v_2); + row[layout.auxiliaries + 108] = v_221; + const uint64_t v_222 = goldilocks_mul(v_217, v_220); + row[layout.auxiliaries + 109] = v_222; + const uint64_t v_225 = seed.word(108); + const uint64_t v_226 = seed.word(109); + const uint64_t v_227 = seed.word(110); + const uint64_t v_228 = seed.word(111); + const uint64_t v_229 = seed.word(112); + const uint64_t v_230 = seed.word(113); + const uint64_t v_231 = seed.word(114); + const uint64_t v_232 = seed.word(115); + row[layout.auxiliaries + 110] = v_225; + row[layout.auxiliaries + 111] = v_226; + row[layout.auxiliaries + 112] = v_227; + row[layout.auxiliaries + 113] = v_228; + row[layout.auxiliaries + 114] = v_229; + row[layout.auxiliaries + 115] = v_230; + row[layout.auxiliaries + 116] = v_231; + row[layout.auxiliaries + 117] = v_232; + const uint64_t v_233 = seed.word(116); + row[layout.auxiliaries + 118] = v_233; + const uint64_t v_234 = goldilocks_mul(v_217, v_233); + row[layout.auxiliaries + 119] = v_234; + const uint64_t v_241 = seed.word(117); + const uint64_t v_242 = seed.word(118); + const uint64_t v_243 = seed.word(119); + const uint64_t v_244 = seed.word(120); + const uint64_t v_245 = seed.word(121); + const uint64_t v_246 = seed.word(122); + const uint64_t v_247 = seed.word(123); + const uint64_t v_248 = seed.word(124); + const uint64_t v_249 = seed.word(125); + const uint64_t v_250 = seed.word(126); + const uint64_t v_251 = seed.word(127); + const uint64_t v_252 = seed.word(128); + const uint64_t v_253 = seed.word(129); + const uint64_t v_254 = seed.word(130); + const uint64_t v_255 = seed.word(131); + const uint64_t v_256 = seed.word(132); + const uint64_t v_257 = seed.word(133); + const uint64_t v_258 = seed.word(134); + const uint64_t v_259 = seed.word(135); + const uint64_t v_260 = seed.word(136); + const uint64_t v_261 = seed.word(137); + const uint64_t v_262 = seed.word(138); + const uint64_t v_263 = seed.word(139); + const uint64_t v_264 = seed.word(140); + const uint64_t v_265 = seed.word(141); + const uint64_t v_266 = seed.word(142); + const uint64_t v_267 = seed.word(143); + const uint64_t v_268 = seed.word(144); + const uint64_t v_269 = seed.word(145); + const uint64_t v_270 = seed.word(146); + const uint64_t v_271 = seed.word(147); + const uint64_t v_272 = seed.word(148); + row[layout.auxiliaries + 120] = v_241; + row[layout.auxiliaries + 121] = v_242; + row[layout.auxiliaries + 122] = v_243; + row[layout.auxiliaries + 123] = v_244; + row[layout.auxiliaries + 124] = v_245; + row[layout.auxiliaries + 125] = v_246; + row[layout.auxiliaries + 126] = v_247; + row[layout.auxiliaries + 127] = v_248; + row[layout.auxiliaries + 128] = v_249; + row[layout.auxiliaries + 129] = v_250; + row[layout.auxiliaries + 130] = v_251; + row[layout.auxiliaries + 131] = v_252; + row[layout.auxiliaries + 132] = v_253; + row[layout.auxiliaries + 133] = v_254; + row[layout.auxiliaries + 134] = v_255; + row[layout.auxiliaries + 135] = v_256; + row[layout.auxiliaries + 136] = v_257; + row[layout.auxiliaries + 137] = v_258; + row[layout.auxiliaries + 138] = v_259; + row[layout.auxiliaries + 139] = v_260; + row[layout.auxiliaries + 140] = v_261; + row[layout.auxiliaries + 141] = v_262; + row[layout.auxiliaries + 142] = v_263; + row[layout.auxiliaries + 143] = v_264; + row[layout.auxiliaries + 144] = v_265; + row[layout.auxiliaries + 145] = v_266; + row[layout.auxiliaries + 146] = v_267; + row[layout.auxiliaries + 147] = v_268; + row[layout.auxiliaries + 148] = v_269; + row[layout.auxiliaries + 149] = v_270; + row[layout.auxiliaries + 150] = v_271; + row[layout.auxiliaries + 151] = v_272; + const uint64_t v_289 = seed.word(149); + const uint64_t v_290 = seed.word(150); + const uint64_t v_291 = seed.word(151); + const uint64_t v_292 = seed.word(152); + const uint64_t v_293 = seed.word(153); + const uint64_t v_294 = seed.word(154); + const uint64_t v_295 = seed.word(155); + const uint64_t v_296 = seed.word(156); + const uint64_t v_297 = seed.word(157); + const uint64_t v_298 = seed.word(158); + const uint64_t v_299 = seed.word(159); + const uint64_t v_300 = seed.word(160); + const uint64_t v_301 = seed.word(161); + const uint64_t v_302 = seed.word(162); + const uint64_t v_303 = seed.word(163); + const uint64_t v_304 = seed.word(164); + const uint64_t v_305 = seed.word(165); + const uint64_t v_306 = seed.word(166); + const uint64_t v_307 = seed.word(167); + const uint64_t v_308 = seed.word(168); + const uint64_t v_309 = seed.word(169); + const uint64_t v_310 = seed.word(170); + const uint64_t v_311 = seed.word(171); + const uint64_t v_312 = seed.word(172); + const uint64_t v_313 = seed.word(173); + const uint64_t v_314 = seed.word(174); + const uint64_t v_315 = seed.word(175); + const uint64_t v_316 = seed.word(176); + const uint64_t v_317 = seed.word(177); + const uint64_t v_318 = seed.word(178); + const uint64_t v_319 = seed.word(179); + const uint64_t v_320 = seed.word(180); + row[layout.auxiliaries + 152] = v_289; + row[layout.auxiliaries + 153] = v_290; + row[layout.auxiliaries + 154] = v_291; + row[layout.auxiliaries + 155] = v_292; + row[layout.auxiliaries + 156] = v_293; + row[layout.auxiliaries + 157] = v_294; + row[layout.auxiliaries + 158] = v_295; + row[layout.auxiliaries + 159] = v_296; + row[layout.auxiliaries + 160] = v_297; + row[layout.auxiliaries + 161] = v_298; + row[layout.auxiliaries + 162] = v_299; + row[layout.auxiliaries + 163] = v_300; + row[layout.auxiliaries + 164] = v_301; + row[layout.auxiliaries + 165] = v_302; + row[layout.auxiliaries + 166] = v_303; + row[layout.auxiliaries + 167] = v_304; + row[layout.auxiliaries + 168] = v_305; + row[layout.auxiliaries + 169] = v_306; + row[layout.auxiliaries + 170] = v_307; + row[layout.auxiliaries + 171] = v_308; + row[layout.auxiliaries + 172] = v_309; + row[layout.auxiliaries + 173] = v_310; + row[layout.auxiliaries + 174] = v_311; + row[layout.auxiliaries + 175] = v_312; + row[layout.auxiliaries + 176] = v_313; + row[layout.auxiliaries + 177] = v_314; + row[layout.auxiliaries + 178] = v_315; + row[layout.auxiliaries + 179] = v_316; + row[layout.auxiliaries + 180] = v_317; + row[layout.auxiliaries + 181] = v_318; + row[layout.auxiliaries + 182] = v_319; + row[layout.auxiliaries + 183] = v_320; + switch (v_217) { + case 1ULL: { + const uint64_t v_322 = seed.word(181); + row[layout.auxiliaries + 184] = v_322; + row[layout.selectors + 12] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 184] = (v_217 <= 1ULL ? inverse_114_12[v_217] : inverse(goldilocks_sub(v_217, 1ULL))); + switch (v_220) { + case 1ULL: { + const uint64_t v_355 = seed.word(181); + const uint64_t v_356 = seed.word(182); + const uint64_t v_357 = seed.word(183); + const uint64_t v_358 = seed.word(184); + const uint64_t v_359 = seed.word(185); + const uint64_t v_360 = seed.word(186); + const uint64_t v_361 = seed.word(187); + const uint64_t v_362 = seed.word(188); + row[layout.auxiliaries + 185] = v_355; + row[layout.auxiliaries + 186] = v_356; + row[layout.auxiliaries + 187] = v_357; + row[layout.auxiliaries + 188] = v_358; + row[layout.auxiliaries + 189] = v_359; + row[layout.auxiliaries + 190] = v_360; + row[layout.auxiliaries + 191] = v_361; + row[layout.auxiliaries + 192] = v_362; + const uint64_t v_363 = seed.word(189); + const uint64_t v_364 = seed.word(190); + const uint64_t v_365 = seed.word(191); + const uint64_t v_366 = seed.word(192); + const uint64_t v_367 = seed.word(193); + const uint64_t v_368 = seed.word(194); + const uint64_t v_369 = seed.word(195); + const uint64_t v_370 = seed.word(196); + row[layout.auxiliaries + 193] = v_363; + row[layout.auxiliaries + 194] = v_364; + row[layout.auxiliaries + 195] = v_365; + row[layout.auxiliaries + 196] = v_366; + row[layout.auxiliaries + 197] = v_367; + row[layout.auxiliaries + 198] = v_368; + row[layout.auxiliaries + 199] = v_369; + row[layout.auxiliaries + 200] = v_370; + const uint64_t v_371 = seed.word(197); + row[layout.auxiliaries + 201] = v_371; + const uint64_t v_372 = seed.word(198); + row[layout.auxiliaries + 202] = v_372; + const uint64_t v_373 = seed.word(199); + row[layout.auxiliaries + 203] = v_373; + const uint64_t v_374 = seed.word(200); + row[layout.auxiliaries + 204] = v_374; + row[layout.selectors + 13] = 1; + return 0; + } + default: { + row[layout.auxiliaries + 185] = (v_220 <= 1ULL ? inverse_114_13[v_220] : inverse(goldilocks_sub(v_220, 1ULL))); + const uint64_t v_377 = seed.word(181); + row[layout.auxiliaries + 186] = v_377; + const uint64_t v_378 = seed.word(182); + row[layout.auxiliaries + 187] = v_378; + row[layout.selectors + 14] = 1; + return 0; + } + } + } + } + } + } +} +template __global__ void kernel_multi_stark_114(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 544 : 1608; + const Seed_multi_stark_114 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_114(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_114(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_114<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_114<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_114(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 6 || auxiliaries < selectors || auxiliaries - selectors < 15 || width < auxiliaries || width - auxiliaries < 205) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 544 : encoding == 0 ? 1608 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_114); +} + +template struct Seed_multi_stark_172 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 360); + case 2: return load_u32(data + 364); + case 3: return load_u8(data + 448); + case 4: return load_u64(data + 8); + case 5: return load_u32(data + 368); + case 6: return load_u32(data + 372); + case 7: return load_u64(data + 16); + case 8: return load_u32(data + 376); + case 9: return load_u32(data + 380); + case 10: return load_u64(data + 24); + case 11: return load_u64(data + 32); + case 12: return load_u64(data + 40); + case 13: return load_u64(data + 48); + case 14: return load_u64(data + 56); + case 15: return load_u64(data + 64); + case 16: return load_u64(data + 72); + case 17: return load_u64(data + 80); + case 18: return load_u64(data + 88); + case 19: return load_u64(data + 96); + case 20: return load_u64(data + 104); + case 21: return load_u64(data + 112); + case 22: return load_u64(data + 120); + case 23: return load_u64(data + 128); + case 24: return load_u64(data + 136); + case 25: return load_u64(data + 144); + case 26: return load_u64(data + 152); + case 27: return load_u64(data + 160); + case 28: return load_u64(data + 168); + case 29: return load_u64(data + 176); + case 30: return load_u64(data + 184); + case 31: return load_u64(data + 192); + case 32: return load_u64(data + 200); + case 33: return load_u64(data + 208); + case 34: return load_u64(data + 216); + case 35: return load_u64(data + 224); + case 36: return load_u64(data + 232); + case 37: return load_u64(data + 240); + case 38: return load_u64(data + 248); + case 39: return load_u64(data + 256); + case 40: return load_u64(data + 264); + case 41: return load_u64(data + 272); + case 42: return load_u64(data + 280); + case 43: return load_u32(data + 384); + case 44: return load_u32(data + 388); + case 45: return load_u32(data + 392); + case 46: return load_u32(data + 396); + case 47: return load_u32(data + 400); + case 48: return load_u32(data + 404); + case 49: return load_u32(data + 408); + case 50: return load_u32(data + 412); + case 51: return load_u32(data + 416); + case 52: return load_u8(data + 449); + case 53: return load_u64(data + 288); + case 54: return load_u32(data + 420); + case 55: return load_u8(data + 450); + case 56: return load_u64(data + 296); + case 57: return load_u32(data + 424); + case 58: return load_u8(data + 451); + case 59: return load_u64(data + 304); + case 60: return load_u32(data + 428); + case 61: return load_u8(data + 452); + case 62: return load_u64(data + 312); + case 63: return load_u32(data + 432); + case 64: return load_u8(data + 453); + case 65: return load_u64(data + 320); + case 66: return load_u32(data + 436); + case 67: return load_u8(data + 454); + case 68: return load_u64(data + 328); + case 69: return load_u32(data + 440); + case 70: return load_u8(data + 455); + case 71: return load_u64(data + 336); + case 72: return load_u32(data + 444); + case 73: return load_u8(data + 456); + case 74: return load_u64(data + 344); + case 75: return load_u64(data + 352); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_172(Seed_multi_stark_172 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_37 = seed.word(6); + row[layout.auxiliaries + 4] = v_37; + const uint64_t v_39 = seed.word(7); + row[layout.auxiliaries + 5] = v_39; + const uint64_t v_40 = seed.word(8); + row[layout.auxiliaries + 6] = v_40; + const uint64_t v_41 = seed.word(9); + row[layout.auxiliaries + 7] = v_41; + const uint64_t v_42 = seed.word(10); + row[layout.auxiliaries + 8] = v_42; + const uint64_t v_43 = seed.word(11); + const uint64_t v_44 = seed.word(12); + const uint64_t v_45 = seed.word(13); + const uint64_t v_46 = seed.word(14); + const uint64_t v_47 = seed.word(15); + const uint64_t v_48 = seed.word(16); + const uint64_t v_49 = seed.word(17); + const uint64_t v_50 = seed.word(18); + const uint64_t v_51 = seed.word(19); + const uint64_t v_52 = seed.word(20); + const uint64_t v_53 = seed.word(21); + const uint64_t v_54 = seed.word(22); + const uint64_t v_55 = seed.word(23); + const uint64_t v_56 = seed.word(24); + const uint64_t v_57 = seed.word(25); + const uint64_t v_58 = seed.word(26); + const uint64_t v_59 = seed.word(27); + const uint64_t v_60 = seed.word(28); + const uint64_t v_61 = seed.word(29); + const uint64_t v_62 = seed.word(30); + const uint64_t v_63 = seed.word(31); + const uint64_t v_64 = seed.word(32); + const uint64_t v_65 = seed.word(33); + const uint64_t v_66 = seed.word(34); + const uint64_t v_67 = seed.word(35); + const uint64_t v_68 = seed.word(36); + const uint64_t v_69 = seed.word(37); + const uint64_t v_70 = seed.word(38); + const uint64_t v_71 = seed.word(39); + const uint64_t v_72 = seed.word(40); + const uint64_t v_73 = seed.word(41); + const uint64_t v_74 = seed.word(42); + row[layout.auxiliaries + 9] = v_43; + row[layout.auxiliaries + 10] = v_44; + row[layout.auxiliaries + 11] = v_45; + row[layout.auxiliaries + 12] = v_46; + row[layout.auxiliaries + 13] = v_47; + row[layout.auxiliaries + 14] = v_48; + row[layout.auxiliaries + 15] = v_49; + row[layout.auxiliaries + 16] = v_50; + row[layout.auxiliaries + 17] = v_51; + row[layout.auxiliaries + 18] = v_52; + row[layout.auxiliaries + 19] = v_53; + row[layout.auxiliaries + 20] = v_54; + row[layout.auxiliaries + 21] = v_55; + row[layout.auxiliaries + 22] = v_56; + row[layout.auxiliaries + 23] = v_57; + row[layout.auxiliaries + 24] = v_58; + row[layout.auxiliaries + 25] = v_59; + row[layout.auxiliaries + 26] = v_60; + row[layout.auxiliaries + 27] = v_61; + row[layout.auxiliaries + 28] = v_62; + row[layout.auxiliaries + 29] = v_63; + row[layout.auxiliaries + 30] = v_64; + row[layout.auxiliaries + 31] = v_65; + row[layout.auxiliaries + 32] = v_66; + row[layout.auxiliaries + 33] = v_67; + row[layout.auxiliaries + 34] = v_68; + row[layout.auxiliaries + 35] = v_69; + row[layout.auxiliaries + 36] = v_70; + row[layout.auxiliaries + 37] = v_71; + row[layout.auxiliaries + 38] = v_72; + row[layout.auxiliaries + 39] = v_73; + row[layout.auxiliaries + 40] = v_74; + const uint64_t v_75 = seed.word(43); + row[layout.auxiliaries + 41] = v_75; + const uint64_t v_76 = seed.word(44); + row[layout.auxiliaries + 42] = v_76; + const uint64_t v_77 = seed.word(45); + row[layout.auxiliaries + 43] = v_77; + const uint64_t v_78 = seed.word(46); + row[layout.auxiliaries + 44] = v_78; + const uint64_t v_79 = seed.word(47); + row[layout.auxiliaries + 45] = v_79; + const uint64_t v_80 = seed.word(48); + row[layout.auxiliaries + 46] = v_80; + const uint64_t v_81 = seed.word(49); + row[layout.auxiliaries + 47] = v_81; + const uint64_t v_82 = seed.word(50); + row[layout.auxiliaries + 48] = v_82; + const uint64_t v_83 = seed.word(51); + row[layout.auxiliaries + 49] = v_83; + const uint64_t v_84 = seed.word(52); + const uint64_t v_85 = seed.word(53); + const uint64_t v_86 = seed.word(54); + row[layout.auxiliaries + 50] = v_84; + row[layout.auxiliaries + 51] = v_85; + row[layout.auxiliaries + 52] = v_86; + switch (v_84) { + case 0ULL: { + const uint64_t v_87 = seed.word(55); + const uint64_t v_88 = seed.word(56); + const uint64_t v_89 = seed.word(57); + row[layout.auxiliaries + 53] = v_87; + row[layout.auxiliaries + 54] = v_88; + row[layout.auxiliaries + 55] = v_89; + switch (v_87) { + case 0ULL: { + const uint64_t v_90 = seed.word(58); + const uint64_t v_91 = seed.word(59); + const uint64_t v_92 = seed.word(60); + row[layout.auxiliaries + 56] = v_90; + row[layout.auxiliaries + 57] = v_91; + row[layout.auxiliaries + 58] = v_92; + switch (v_90) { + case 0ULL: { + const uint64_t v_93 = seed.word(61); + const uint64_t v_94 = seed.word(62); + const uint64_t v_95 = seed.word(63); + row[layout.auxiliaries + 59] = v_93; + row[layout.auxiliaries + 60] = v_94; + row[layout.auxiliaries + 61] = v_95; + switch (v_93) { + case 0ULL: { + const uint64_t v_96 = seed.word(64); + const uint64_t v_97 = seed.word(65); + const uint64_t v_98 = seed.word(66); + row[layout.auxiliaries + 62] = v_96; + row[layout.auxiliaries + 63] = v_97; + row[layout.auxiliaries + 64] = v_98; + switch (v_96) { + case 0ULL: { + const uint64_t v_99 = seed.word(67); + const uint64_t v_100 = seed.word(68); + const uint64_t v_101 = seed.word(69); + row[layout.auxiliaries + 65] = v_99; + row[layout.auxiliaries + 66] = v_100; + row[layout.auxiliaries + 67] = v_101; + switch (v_99) { + case 0ULL: { + const uint64_t v_102 = seed.word(70); + const uint64_t v_103 = seed.word(71); + const uint64_t v_104 = seed.word(72); + row[layout.auxiliaries + 68] = v_102; + row[layout.auxiliaries + 69] = v_103; + row[layout.auxiliaries + 70] = v_104; + switch (v_102) { + case 0ULL: { + const uint64_t v_105 = seed.word(73); + const uint64_t v_106 = seed.word(74); + const uint64_t v_107 = seed.word(75); + row[layout.auxiliaries + 71] = v_105; + row[layout.auxiliaries + 72] = v_106; + row[layout.auxiliaries + 73] = v_107; + switch (v_105) { + case 0ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + case 0ULL: { + const uint64_t v_108 = seed.word(6); + const uint64_t v_109 = seed.word(7); + const uint64_t v_110 = seed.word(8); + row[layout.auxiliaries + 4] = v_108; + row[layout.auxiliaries + 5] = v_109; + row[layout.auxiliaries + 6] = v_110; + switch (v_108) { + case 0ULL: { + const uint64_t v_111 = seed.word(9); + const uint64_t v_112 = seed.word(10); + const uint64_t v_113 = seed.word(11); + row[layout.auxiliaries + 7] = v_111; + row[layout.auxiliaries + 8] = v_112; + row[layout.auxiliaries + 9] = v_113; + switch (v_111) { + case 0ULL: { + const uint64_t v_114 = seed.word(12); + const uint64_t v_115 = seed.word(13); + const uint64_t v_116 = seed.word(14); + row[layout.auxiliaries + 10] = v_114; + row[layout.auxiliaries + 11] = v_115; + row[layout.auxiliaries + 12] = v_116; + switch (v_114) { + case 0ULL: { + const uint64_t v_117 = seed.word(15); + const uint64_t v_118 = seed.word(16); + const uint64_t v_119 = seed.word(17); + row[layout.auxiliaries + 13] = v_117; + row[layout.auxiliaries + 14] = v_118; + row[layout.auxiliaries + 15] = v_119; + switch (v_117) { + case 0ULL: { + const uint64_t v_120 = seed.word(18); + const uint64_t v_121 = seed.word(19); + const uint64_t v_122 = seed.word(20); + row[layout.auxiliaries + 16] = v_120; + row[layout.auxiliaries + 17] = v_121; + row[layout.auxiliaries + 18] = v_122; + switch (v_120) { + case 0ULL: { + const uint64_t v_123 = seed.word(21); + const uint64_t v_124 = seed.word(22); + const uint64_t v_125 = seed.word(23); + row[layout.auxiliaries + 19] = v_123; + row[layout.auxiliaries + 20] = v_124; + row[layout.auxiliaries + 21] = v_125; + switch (v_123) { + case 0ULL: { + const uint64_t v_126 = seed.word(24); + const uint64_t v_127 = seed.word(25); + const uint64_t v_128 = seed.word(26); + row[layout.auxiliaries + 22] = v_126; + row[layout.auxiliaries + 23] = v_127; + row[layout.auxiliaries + 24] = v_128; + switch (v_126) { + case 0ULL: { + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_172(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 464 : 608; + const Seed_multi_stark_172 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_172(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_172(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_172<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_172<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_172(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 74) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 464 : encoding == 0 ? 608 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_172); +} + +template struct Seed_multi_stark_200 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 512); + case 2: return load_u64(data + 8); + case 3: return load_u64(data + 16); + case 4: return load_u64(data + 24); + case 5: return load_u64(data + 32); + case 6: return load_u64(data + 40); + case 7: return load_u8(data + 604); + case 8: return load_u64(data + 48); + case 9: return load_u64(data + 56); + case 10: return load_u64(data + 64); + case 11: return load_u64(data + 72); + case 12: return load_u64(data + 80); + case 13: return load_u64(data + 88); + case 14: return load_u64(data + 96); + case 15: return load_u64(data + 104); + case 16: return load_u64(data + 112); + case 17: return load_u64(data + 120); + case 18: return load_u64(data + 128); + case 19: return load_u64(data + 136); + case 20: return load_u64(data + 144); + case 21: return load_u8(data + 605); + case 22: return load_u32(data + 516); + case 23: return load_u64(data + 152); + case 24: return load_u32(data + 520); + case 25: return load_u64(data + 160); + case 26: return load_u32(data + 524); + case 27: return load_u64(data + 168); + case 28: return load_u64(data + 176); + case 29: return load_u64(data + 184); + case 30: return load_u64(data + 192); + case 31: return load_u32(data + 528); + case 32: return load_u8(data + 606); + case 33: return load_u8(data + 607); + case 34: return load_u64(data + 200); + case 35: return load_u64(data + 208); + case 36: return load_u64(data + 216); + case 37: return load_u32(data + 532); + case 38: return load_u32(data + 536); + case 39: return load_u64(data + 224); + case 40: return load_u32(data + 540); + case 41: return load_u32(data + 544); + case 42: return load_u8(data + 608); + case 43: return load_u64(data + 232); + case 44: return load_u64(data + 240); + case 45: return load_u32(data + 548); + case 46: return load_u32(data + 552); + case 47: return load_u64(data + 248); + case 48: return load_u64(data + 256); + case 49: return load_u64(data + 264); + case 50: return load_u64(data + 272); + case 51: return load_u64(data + 280); + case 52: return load_u64(data + 288); + case 53: return load_u64(data + 296); + case 54: return load_u64(data + 304); + case 55: return load_u64(data + 312); + case 56: return load_u32(data + 556); + case 57: return load_u32(data + 560); + case 58: return load_u32(data + 564); + case 59: return load_u32(data + 568); + case 60: return load_u32(data + 572); + case 61: return load_u32(data + 576); + case 62: return load_u32(data + 580); + case 63: return load_u32(data + 584); + case 64: return load_u32(data + 588); + case 65: return load_u64(data + 320); + case 66: return load_u64(data + 328); + case 67: return load_u64(data + 336); + case 68: return load_u64(data + 344); + case 69: return load_u8(data + 609); + case 70: return load_u64(data + 352); + case 71: return load_u64(data + 360); + case 72: return load_u32(data + 592); + case 73: return load_u64(data + 368); + case 74: return load_u64(data + 376); + case 75: return load_u64(data + 384); + case 76: return load_u64(data + 392); + case 77: return load_u64(data + 400); + case 78: return load_u64(data + 408); + case 79: return load_u64(data + 416); + case 80: return load_u64(data + 424); + case 81: return load_u64(data + 432); + case 82: return load_u64(data + 440); + case 83: return load_u64(data + 448); + case 84: return load_u64(data + 456); + case 85: return load_u64(data + 464); + case 86: return load_u32(data + 596); + case 87: return load_u32(data + 600); + case 88: return load_u64(data + 472); + case 89: return load_u64(data + 480); + case 90: return load_u64(data + 488); + case 91: return load_u64(data + 496); + case 92: return load_u64(data + 504); + case 93: return load_u8(data + 610); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_200(Seed_multi_stark_200 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_16 = seed.word(17); + row[16] = v_16; + const uint64_t v_17 = seed.word(18); + row[17] = v_17; + const uint64_t v_18 = seed.word(19); + row[18] = v_18; + const uint64_t v_19 = seed.word(20); + row[19] = v_19; + const uint64_t v_20 = seed.word(21); + const uint64_t v_21 = seed.word(22); + const uint64_t v_22 = seed.word(23); + const uint64_t v_23 = seed.word(24); + const uint64_t v_24 = seed.word(25); + const uint64_t v_25 = seed.word(26); + const uint64_t v_26 = seed.word(27); + const uint64_t v_27 = seed.word(28); + const uint64_t v_28 = seed.word(29); + const uint64_t v_29 = seed.word(30); + const uint64_t v_30 = seed.word(31); + row[layout.auxiliaries + 1] = v_20; + row[layout.auxiliaries + 2] = v_21; + row[layout.auxiliaries + 3] = v_22; + row[layout.auxiliaries + 4] = v_23; + row[layout.auxiliaries + 5] = v_24; + row[layout.auxiliaries + 6] = v_25; + row[layout.auxiliaries + 7] = v_26; + row[layout.auxiliaries + 8] = v_27; + row[layout.auxiliaries + 9] = v_28; + row[layout.auxiliaries + 10] = v_29; + row[layout.auxiliaries + 11] = v_30; + switch (v_20) { + case 1ULL: { + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + switch (v_21) { + default: { + const uint64_t v_32 = seed.word(32); + row[layout.auxiliaries + 12] = v_32; + const uint64_t v_33 = 32ULL; + if (v_32 > 255 || v_33 > 255) return 1; + const uint64_t v_34 = uint64_t(v_32 < v_33); + row[layout.auxiliaries + 13] = v_34; + const uint64_t v_36 = seed.word(33); + row[layout.auxiliaries + 14] = v_36; + const uint64_t v_37 = seed.word(34); + const uint64_t v_38 = seed.word(35); + row[layout.auxiliaries + 15] = v_37; + row[layout.auxiliaries + 16] = v_38; + const uint64_t v_39 = seed.word(36); + row[layout.auxiliaries + 17] = v_39; + const uint64_t v_41 = seed.word(37); + row[layout.auxiliaries + 18] = v_41; + const uint64_t v_42 = seed.word(38); + row[layout.auxiliaries + 19] = v_42; + const uint64_t v_43 = seed.word(39); + row[layout.auxiliaries + 20] = v_43; + const uint64_t v_44 = seed.word(40); + row[layout.auxiliaries + 21] = v_44; + const uint64_t v_45 = seed.word(41); + row[layout.auxiliaries + 22] = v_45; + const uint64_t v_46 = seed.word(42); + const uint64_t v_47 = seed.word(43); + row[layout.auxiliaries + 23] = v_46; + row[layout.auxiliaries + 24] = v_47; + uint64_t v_57; + uint64_t v_58; + switch (v_46) { + case 0ULL: { + const uint64_t v_49 = seed.word(44); + row[layout.auxiliaries + 25] = v_49; + row[layout.selectors + 1] = 1; + v_57 = v_49; + v_58 = v_49; + goto continuation_0; + } + case 1ULL: { + switch (v_6) { + case 0ULL: { + const uint64_t v_51 = seed.word(44); + row[layout.auxiliaries + 25] = v_51; + row[layout.selectors + 2] = 1; + v_57 = v_51; + v_58 = v_51; + goto continuation_0; + } + case 1ULL: { + const uint64_t v_52 = seed.word(44); + row[layout.auxiliaries + 25] = v_52; + const uint64_t v_54 = seed.word(45); + row[layout.auxiliaries + 26] = v_54; + const uint64_t v_56 = seed.word(46); + row[layout.auxiliaries + 27] = v_56; + row[layout.selectors + 3] = 1; + v_57 = v_54; + v_58 = v_56; + goto continuation_0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } + continuation_0:; + row[layout.auxiliaries + 28] = v_57; + row[layout.auxiliaries + 29] = v_58; + const uint64_t v_59 = seed.word(47); + row[layout.auxiliaries + 30] = v_59; + const uint64_t v_60 = goldilocks_sub(v_59, v_27); + const uint64_t v_61 = uint64_t(v_60 == 0); + row[layout.auxiliaries + 31] = inverse(v_60); + row[layout.auxiliaries + 32] = v_61; + const uint64_t v_62 = 1ULL; + const uint64_t v_63 = seed.word(48); + row[layout.auxiliaries + 33] = v_63; + const uint64_t v_64 = goldilocks_sub(v_63, v_27); + const uint64_t v_65 = uint64_t(v_64 == 0); + row[layout.auxiliaries + 34] = inverse(v_64); + row[layout.auxiliaries + 35] = v_65; + const uint64_t v_66 = seed.word(49); + row[layout.auxiliaries + 36] = v_66; + const uint64_t v_67 = goldilocks_sub(v_66, v_29); + const uint64_t v_68 = uint64_t(v_67 == 0); + row[layout.auxiliaries + 37] = inverse(v_67); + row[layout.auxiliaries + 38] = v_68; + const uint64_t v_69 = seed.word(50); + row[layout.auxiliaries + 39] = v_69; + const uint64_t v_70 = goldilocks_sub(v_69, v_29); + const uint64_t v_71 = uint64_t(v_70 == 0); + row[layout.auxiliaries + 40] = inverse(v_70); + row[layout.auxiliaries + 41] = v_71; + const uint64_t v_72 = seed.word(51); + row[layout.auxiliaries + 42] = v_72; + const uint64_t v_73 = goldilocks_sub(v_72, v_28); + const uint64_t v_74 = uint64_t(v_73 == 0); + row[layout.auxiliaries + 43] = inverse(v_73); + row[layout.auxiliaries + 44] = v_74; + const uint64_t v_75 = seed.word(52); + row[layout.auxiliaries + 45] = v_75; + const uint64_t v_76 = goldilocks_sub(v_75, v_28); + const uint64_t v_77 = uint64_t(v_76 == 0); + row[layout.auxiliaries + 46] = inverse(v_76); + row[layout.auxiliaries + 47] = v_77; + const uint64_t v_78 = seed.word(53); + const uint64_t v_79 = seed.word(54); + row[layout.auxiliaries + 48] = v_78; + row[layout.auxiliaries + 49] = v_79; + const uint64_t v_80 = 0ULL; + const uint64_t v_81 = goldilocks_sub(v_78, v_62); + const uint64_t v_82 = goldilocks_sub(v_79, v_80); + const uint64_t v_83 = seed.word(55); + row[layout.auxiliaries + 50] = v_83; + const uint64_t v_84 = inverse(v_83); + row[layout.auxiliaries + 51] = v_84; + const uint64_t v_85 = goldilocks_mul(v_83, v_84); + row[layout.auxiliaries + 52] = v_85; + const uint64_t v_86 = goldilocks_sub(v_85, v_62); + const uint64_t v_87 = goldilocks_mul(v_83, v_86); + row[layout.auxiliaries + 53] = v_87; + const uint64_t v_88 = goldilocks_mul(v_84, v_86); + row[layout.auxiliaries + 54] = v_88; + const uint64_t v_89 = goldilocks_sub(v_18, v_62); + const uint64_t v_90 = goldilocks_sub(v_19, v_80); + const uint64_t v_91 = goldilocks_mul(v_89, v_89); + row[layout.auxiliaries + 55] = v_91; + const uint64_t v_92 = 7ULL; + const uint64_t v_93 = goldilocks_mul(v_90, v_90); + row[layout.auxiliaries + 56] = v_93; + const uint64_t v_94 = goldilocks_mul(v_92, v_93); + const uint64_t v_95 = goldilocks_sub(v_91, v_94); + const uint64_t v_96 = inverse(v_95); + row[layout.auxiliaries + 57] = v_96; + const uint64_t v_97 = goldilocks_mul(v_95, v_96); + row[layout.auxiliaries + 58] = v_97; + const uint64_t v_98 = goldilocks_sub(v_97, v_62); + const uint64_t v_99 = goldilocks_mul(v_95, v_98); + row[layout.auxiliaries + 59] = v_99; + const uint64_t v_100 = goldilocks_mul(v_96, v_98); + row[layout.auxiliaries + 60] = v_100; + const uint64_t v_101 = goldilocks_mul(v_89, v_96); + row[layout.auxiliaries + 61] = v_101; + const uint64_t v_102 = goldilocks_sub(v_80, v_90); + const uint64_t v_103 = goldilocks_mul(v_102, v_96); + row[layout.auxiliaries + 62] = v_103; + const uint64_t v_104 = goldilocks_mul(v_81, v_101); + row[layout.auxiliaries + 63] = v_104; + const uint64_t v_105 = goldilocks_mul(v_82, v_103); + row[layout.auxiliaries + 64] = v_105; + const uint64_t v_108 = goldilocks_mul(v_81, v_103); + row[layout.auxiliaries + 65] = v_108; + const uint64_t v_109 = goldilocks_mul(v_82, v_101); + row[layout.auxiliaries + 66] = v_109; + const uint64_t v_111 = goldilocks_sub(v_18, v_84); + const uint64_t v_112 = goldilocks_mul(v_111, v_111); + row[layout.auxiliaries + 67] = v_112; + const uint64_t v_113 = goldilocks_sub(v_112, v_94); + const uint64_t v_114 = inverse(v_113); + row[layout.auxiliaries + 68] = v_114; + const uint64_t v_115 = goldilocks_mul(v_113, v_114); + row[layout.auxiliaries + 69] = v_115; + const uint64_t v_116 = goldilocks_sub(v_115, v_62); + const uint64_t v_117 = goldilocks_mul(v_113, v_116); + row[layout.auxiliaries + 70] = v_117; + const uint64_t v_118 = goldilocks_mul(v_114, v_116); + row[layout.auxiliaries + 71] = v_118; + const uint64_t v_119 = goldilocks_mul(v_111, v_114); + row[layout.auxiliaries + 72] = v_119; + const uint64_t v_120 = goldilocks_mul(v_102, v_114); + row[layout.auxiliaries + 73] = v_120; + const uint64_t v_121 = goldilocks_mul(v_81, v_119); + row[layout.auxiliaries + 74] = v_121; + const uint64_t v_122 = goldilocks_mul(v_82, v_120); + row[layout.auxiliaries + 75] = v_122; + const uint64_t v_123 = goldilocks_mul(v_92, v_122); + const uint64_t v_124 = goldilocks_add(v_121, v_123); + const uint64_t v_125 = goldilocks_mul(v_81, v_120); + row[layout.auxiliaries + 76] = v_125; + const uint64_t v_126 = goldilocks_mul(v_82, v_119); + row[layout.auxiliaries + 77] = v_126; + const uint64_t v_127 = goldilocks_add(v_125, v_126); + const uint64_t v_128 = goldilocks_mul(v_81, v_81); + row[layout.auxiliaries + 78] = v_128; + const uint64_t v_129 = goldilocks_mul(v_82, v_82); + row[layout.auxiliaries + 79] = v_129; + const uint64_t v_130 = goldilocks_mul(v_92, v_129); + const uint64_t v_131 = goldilocks_sub(v_128, v_130); + const uint64_t v_132 = inverse(v_131); + row[layout.auxiliaries + 80] = v_132; + const uint64_t v_133 = goldilocks_mul(v_131, v_132); + row[layout.auxiliaries + 81] = v_133; + const uint64_t v_134 = goldilocks_sub(v_133, v_62); + const uint64_t v_135 = goldilocks_mul(v_131, v_134); + row[layout.auxiliaries + 82] = v_135; + const uint64_t v_136 = goldilocks_mul(v_132, v_134); + row[layout.auxiliaries + 83] = v_136; + const uint64_t v_137 = goldilocks_mul(v_81, v_132); + row[layout.auxiliaries + 84] = v_137; + const uint64_t v_138 = goldilocks_sub(v_80, v_82); + const uint64_t v_139 = goldilocks_mul(v_138, v_132); + row[layout.auxiliaries + 85] = v_139; + const uint64_t v_140 = seed.word(56); + row[layout.auxiliaries + 86] = v_140; + const uint64_t v_141 = seed.word(57); + row[layout.auxiliaries + 87] = v_141; + const uint64_t v_142 = seed.word(58); + row[layout.auxiliaries + 88] = v_142; + const uint64_t v_143 = seed.word(59); + row[layout.auxiliaries + 89] = v_143; + const uint64_t v_144 = seed.word(60); + row[layout.auxiliaries + 90] = v_144; + const uint64_t v_145 = seed.word(61); + row[layout.auxiliaries + 91] = v_145; + const uint64_t v_146 = seed.word(62); + row[layout.auxiliaries + 92] = v_146; + const uint64_t v_147 = seed.word(63); + row[layout.auxiliaries + 93] = v_147; + const uint64_t v_148 = seed.word(64); + row[layout.auxiliaries + 94] = v_148; + const uint64_t v_149 = seed.word(65); + row[layout.auxiliaries + 95] = v_149; + const uint64_t v_150 = seed.word(66); + row[layout.auxiliaries + 96] = v_150; + const uint64_t v_151 = goldilocks_mul(v_149, v_150); + row[layout.auxiliaries + 97] = v_151; + const uint64_t v_152 = inverse(v_151); + row[layout.auxiliaries + 98] = v_152; + const uint64_t v_153 = goldilocks_mul(v_151, v_152); + row[layout.auxiliaries + 99] = v_153; + const uint64_t v_154 = goldilocks_sub(v_153, v_62); + const uint64_t v_155 = goldilocks_mul(v_151, v_154); + row[layout.auxiliaries + 100] = v_155; + const uint64_t v_156 = goldilocks_mul(v_152, v_154); + row[layout.auxiliaries + 101] = v_156; + const uint64_t v_157 = seed.word(67); + const uint64_t v_158 = seed.word(68); + row[layout.auxiliaries + 102] = v_157; + row[layout.auxiliaries + 103] = v_158; + const uint64_t v_159 = goldilocks_sub(v_37, v_10); + const uint64_t v_160 = goldilocks_sub(v_80, v_80); + const uint64_t v_161 = goldilocks_mul(v_159, v_152); + row[layout.auxiliaries + 104] = v_161; + const uint64_t v_162 = goldilocks_mul(v_160, v_80); + const uint64_t v_163 = goldilocks_mul(v_92, v_162); + const uint64_t v_164 = goldilocks_add(v_161, v_163); + const uint64_t v_165 = goldilocks_mul(v_159, v_80); + const uint64_t v_166 = goldilocks_mul(v_160, v_152); + const uint64_t v_167 = goldilocks_add(v_165, v_166); + const uint64_t v_168 = goldilocks_mul(v_124, v_164); + row[layout.auxiliaries + 105] = v_168; + const uint64_t v_169 = goldilocks_mul(v_127, v_167); + row[layout.auxiliaries + 106] = v_169; + const uint64_t v_172 = goldilocks_mul(v_124, v_167); + row[layout.auxiliaries + 107] = v_172; + const uint64_t v_173 = goldilocks_mul(v_127, v_164); + row[layout.auxiliaries + 108] = v_173; + const uint64_t v_175 = goldilocks_sub(v_38, v_11); + const uint64_t v_176 = goldilocks_mul(v_175, v_152); + row[layout.auxiliaries + 109] = v_176; + const uint64_t v_177 = goldilocks_add(v_176, v_163); + const uint64_t v_178 = goldilocks_mul(v_175, v_80); + const uint64_t v_179 = goldilocks_add(v_178, v_166); + const uint64_t v_180 = goldilocks_mul(v_124, v_177); + row[layout.auxiliaries + 110] = v_180; + const uint64_t v_181 = goldilocks_mul(v_127, v_179); + row[layout.auxiliaries + 111] = v_181; + const uint64_t v_184 = goldilocks_mul(v_124, v_179); + row[layout.auxiliaries + 112] = v_184; + const uint64_t v_185 = goldilocks_mul(v_127, v_177); + row[layout.auxiliaries + 113] = v_185; + const uint64_t v_187 = seed.word(69); + const uint64_t v_188 = seed.word(70); + const uint64_t v_189 = seed.word(71); + const uint64_t v_190 = seed.word(72); + row[layout.auxiliaries + 114] = v_187; + row[layout.auxiliaries + 115] = v_188; + row[layout.auxiliaries + 116] = v_189; + row[layout.auxiliaries + 117] = v_190; + uint64_t v_218; + uint64_t v_219; + switch (v_187) { + case 1ULL: { + const uint64_t v_192 = seed.word(73); + const uint64_t v_193 = seed.word(74); + row[layout.auxiliaries + 118] = v_192; + row[layout.auxiliaries + 119] = v_193; + const uint64_t v_194 = seed.word(75); + const uint64_t v_195 = seed.word(76); + row[layout.auxiliaries + 120] = v_194; + row[layout.auxiliaries + 121] = v_195; + const uint64_t v_200 = seed.word(77); + const uint64_t v_201 = seed.word(78); + row[layout.auxiliaries + 122] = v_200; + row[layout.auxiliaries + 123] = v_201; + const uint64_t v_203 = seed.word(79); + const uint64_t v_204 = seed.word(80); + row[layout.auxiliaries + 124] = v_203; + row[layout.auxiliaries + 125] = v_204; + const uint64_t v_205 = seed.word(81); + const uint64_t v_206 = seed.word(82); + row[layout.auxiliaries + 126] = v_205; + row[layout.auxiliaries + 127] = v_206; + const uint64_t v_211 = seed.word(83); + const uint64_t v_212 = seed.word(84); + row[layout.auxiliaries + 128] = v_211; + row[layout.auxiliaries + 129] = v_212; + row[layout.selectors + 4] = 1; + v_218 = v_211; + v_219 = v_212; + goto continuation_1; + } + case 0ULL: { + const uint64_t v_214 = seed.word(73); + row[layout.auxiliaries + 118] = v_214; + const uint64_t v_216 = seed.word(74); + const uint64_t v_217 = seed.word(75); + row[layout.auxiliaries + 119] = v_216; + row[layout.auxiliaries + 120] = v_217; + row[layout.selectors + 5] = 1; + v_218 = v_216; + v_219 = v_217; + goto continuation_1; + } + default: { + return 2; + } + } + continuation_1:; + row[layout.auxiliaries + 130] = v_218; + row[layout.auxiliaries + 131] = v_219; + const uint64_t v_220 = seed.word(85); + row[layout.auxiliaries + 132] = v_220; + const uint64_t v_222 = seed.word(86); + row[layout.auxiliaries + 133] = v_222; + const uint64_t v_223 = seed.word(87); + row[layout.auxiliaries + 134] = v_223; + const uint64_t v_224 = seed.word(88); + row[layout.auxiliaries + 135] = v_224; + const uint64_t v_225 = goldilocks_sub(v_224, v_36); + const uint64_t v_226 = uint64_t(v_225 == 0); + row[layout.auxiliaries + 136] = inverse(v_225); + row[layout.auxiliaries + 137] = v_226; + const uint64_t v_228 = seed.word(89); + const uint64_t v_229 = seed.word(90); + row[layout.auxiliaries + 138] = v_228; + row[layout.auxiliaries + 139] = v_229; + const uint64_t v_230 = seed.word(91); + const uint64_t v_231 = seed.word(92); + row[layout.auxiliaries + 140] = v_230; + row[layout.auxiliaries + 141] = v_231; + const uint64_t v_232 = goldilocks_mul(v_218, v_137); + row[layout.auxiliaries + 142] = v_232; + const uint64_t v_233 = 7ULL; + const uint64_t v_234 = goldilocks_mul(v_219, v_139); + row[layout.auxiliaries + 143] = v_234; + const uint64_t v_235 = goldilocks_mul(v_233, v_234); + const uint64_t v_236 = goldilocks_add(v_232, v_235); + const uint64_t v_237 = goldilocks_mul(v_218, v_139); + row[layout.auxiliaries + 144] = v_237; + const uint64_t v_238 = goldilocks_mul(v_219, v_137); + row[layout.auxiliaries + 145] = v_238; + const uint64_t v_239 = goldilocks_add(v_237, v_238); + const uint64_t v_240 = goldilocks_sub(v_236, v_230); + const uint64_t v_241 = uint64_t(v_240 == 0); + row[layout.auxiliaries + 146] = inverse(v_240); + row[layout.auxiliaries + 147] = v_241; + const uint64_t v_242 = goldilocks_sub(v_239, v_231); + const uint64_t v_243 = uint64_t(v_242 == 0); + row[layout.auxiliaries + 148] = inverse(v_242); + row[layout.auxiliaries + 149] = v_243; + const uint64_t v_244 = goldilocks_mul(v_241, v_243); + row[layout.auxiliaries + 150] = v_244; + const uint64_t v_246 = seed.word(93); + row[layout.auxiliaries + 151] = v_246; + row[layout.selectors + 6] = 1; + return 0; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_200(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 616 : 752; + const Seed_multi_stark_200 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_200(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_200(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_200<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_200<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_200(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 20 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 152) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 616 : encoding == 0 ? 752 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_200); +} + +template struct Seed_multi_stark_217 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u32(data + 8); + case 2: return load_u32(data + 12); + case 3: return load_u8(data + 32); + case 4: return load_u32(data + 16); + case 5: return load_u32(data + 20); + case 6: return load_u8(data + 33); + case 7: return load_u32(data + 24); + case 8: return load_u32(data + 28); + case 9: return load_u8(data + 34); + case 10: return load_u8(data + 35); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_217(Seed_multi_stark_217 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + const uint64_t v_3 = seed.word(4); + const uint64_t v_4 = seed.word(5); + row[layout.auxiliaries + 1] = v_2; + row[layout.auxiliaries + 2] = v_3; + row[layout.auxiliaries + 3] = v_4; + switch (v_2) { + case 1ULL: { + const uint64_t v_5 = seed.word(6); + const uint64_t v_6 = seed.word(7); + const uint64_t v_7 = seed.word(8); + row[layout.auxiliaries + 4] = v_5; + row[layout.auxiliaries + 5] = v_6; + row[layout.auxiliaries + 6] = v_7; + row[layout.selectors + 0] = 1; + return 0; + } + case 0ULL: { + const uint64_t v_9 = seed.word(6); + const uint64_t v_10 = seed.word(7); + const uint64_t v_11 = seed.word(8); + row[layout.auxiliaries + 4] = v_9; + row[layout.auxiliaries + 5] = v_10; + row[layout.auxiliaries + 6] = v_11; + switch (v_9) { + case 0ULL: { + const uint64_t v_12 = seed.word(9); + row[layout.auxiliaries + 7] = v_12; + const uint64_t v_14 = seed.word(10); + row[layout.auxiliaries + 8] = v_14; + row[layout.selectors + 1] = 1; + return 0; + } + default: { + return 2; + } + } + } + default: { + return 2; + } + } +} +template __global__ void kernel_multi_stark_217(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 40 : 88; + const Seed_multi_stark_217 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_217(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_217(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_217<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_217<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_217(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 2 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 88 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_217); +} + +template struct Seed_multi_stark_227 { + const uint8_t* data; + __device__ __forceinline__ uint64_t word(size_t index) const { + if constexpr (!Typed) return reinterpret_cast(data)[index]; + switch (index) { + case 0: return load_u64(data + 0); + case 1: return load_u8(data + 72); + case 2: return load_u8(data + 73); + case 3: return load_u8(data + 74); + case 4: return load_u8(data + 75); + case 5: return load_u8(data + 76); + case 6: return load_u8(data + 77); + case 7: return load_u8(data + 78); + case 8: return load_u8(data + 79); + case 9: return load_u8(data + 80); + case 10: return load_u8(data + 81); + case 11: return load_u8(data + 82); + case 12: return load_u8(data + 83); + case 13: return load_u8(data + 84); + case 14: return load_u8(data + 85); + case 15: return load_u8(data + 86); + case 16: return load_u8(data + 87); + case 17: return load_u64(data + 8); + case 18: return load_u64(data + 16); + case 19: return load_u64(data + 24); + case 20: return load_u64(data + 32); + case 21: return load_u64(data + 40); + case 22: return load_u64(data + 48); + case 23: return load_u64(data + 56); + case 24: return load_u64(data + 64); + default: return 0; + } + } +}; +template __device__ __forceinline__ uint32_t row_multi_stark_227(Seed_multi_stark_227 seed, Layout layout, uint64_t* row) { + const uint64_t v_0 = seed.word(1); + row[0] = v_0; + const uint64_t v_1 = seed.word(2); + row[1] = v_1; + const uint64_t v_2 = seed.word(3); + row[2] = v_2; + const uint64_t v_3 = seed.word(4); + row[3] = v_3; + const uint64_t v_4 = seed.word(5); + row[4] = v_4; + const uint64_t v_5 = seed.word(6); + row[5] = v_5; + const uint64_t v_6 = seed.word(7); + row[6] = v_6; + const uint64_t v_7 = seed.word(8); + row[7] = v_7; + const uint64_t v_8 = seed.word(9); + row[8] = v_8; + const uint64_t v_9 = seed.word(10); + row[9] = v_9; + const uint64_t v_10 = seed.word(11); + row[10] = v_10; + const uint64_t v_11 = seed.word(12); + row[11] = v_11; + const uint64_t v_12 = seed.word(13); + row[12] = v_12; + const uint64_t v_13 = seed.word(14); + row[13] = v_13; + const uint64_t v_14 = seed.word(15); + row[14] = v_14; + const uint64_t v_15 = seed.word(16); + row[15] = v_15; + const uint64_t v_17 = seed.word(17); + row[layout.auxiliaries + 1] = v_17; + const uint64_t v_18 = seed.word(18); + row[layout.auxiliaries + 2] = v_18; + const uint64_t v_19 = seed.word(19); + row[layout.auxiliaries + 3] = v_19; + const uint64_t v_20 = seed.word(20); + row[layout.auxiliaries + 4] = v_20; + const uint64_t v_21 = seed.word(21); + row[layout.auxiliaries + 5] = v_21; + const uint64_t v_22 = seed.word(22); + row[layout.auxiliaries + 6] = v_22; + const uint64_t v_23 = seed.word(23); + row[layout.auxiliaries + 7] = v_23; + const uint64_t v_24 = seed.word(24); + row[layout.auxiliaries + 8] = v_24; + row[layout.selectors + 0] = 1; + return 0; +} +template __global__ void kernel_multi_stark_227(const uint8_t* __restrict__ seeds, size_t real, size_t rows, Layout layout, uint64_t* __restrict__ output, uint32_t* error) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + constexpr size_t stride = Typed ? 88 : 200; + const Seed_multi_stark_227 seed{seeds + r * stride}; + row[layout.auxiliaries] = seed.word(0); + const uint32_t status = row_multi_stark_227(seed, layout, row); + if (status) atomicCAS(error, 0U, status); +} +cudaError_t launch_multi_stark_227(const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + if (encoding == 1) kernel_multi_stark_227<<>>(seeds, real, rows, layout, output, error); + else kernel_multi_stark_227<<>>(seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +extern "C" int aiur_trace_multi_stark_227(int device, const uint8_t* seeds, uint32_t encoding, size_t real, size_t rows, size_t width, size_t selectors, size_t auxiliaries, uint64_t* output) { + if (selectors < 16 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 9) return int(cudaErrorInvalidValue); + const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 200 : 0; + return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_multi_stark_227); +} + +extern "C" const uint8_t* aiur_trace_multi_stark_contract() { + static const uint8_t hash[32] = {190, 78, 33, 75, 247, 82, 112, 163, 173, 204, 83, 141, 6, 196, 161, 203, 161, 99, 163, 87, 1, 40, 26, 136, 174, 21, 15, 159, 197, 168, 147, 208}; + return hash; +} +extern "C" const uint8_t* aiur_trace_multi_stark_schema() { + static const uint8_t hash[32] = {109, 2, 169, 223, 182, 235, 170, 183, 207, 233, 133, 131, 184, 190, 222, 84, 214, 112, 75, 166, 158, 14, 240, 158, 71, 104, 37, 253, 148, 167, 237, 188}; + return hash; +} +} diff --git a/crates/aiur/cuda/generated/production/trace-manifest.json b/crates/aiur/cuda/generated/production/trace-manifest.json new file mode 100644 index 000000000..a0827c6c9 --- /dev/null +++ b/crates/aiur/cuda/generated/production/trace-manifest.json @@ -0,0 +1,104 @@ +{"units": + [{"source": "cuda/generated/production/ixvm.cu", + "digest": + [192, + 136, + 216, + 158, + 123, + 224, + 195, + 160, + 149, + 190, + 172, + 207, + 207, + 149, + 247, + 151, + 76, + 75, + 44, + 67, + 29, + 2, + 99, + 204, + 10, + 89, + 229, + 128, + 106, + 195, + 187, + 251]}, + {"source": "cuda/generated/production/multi_stark.cu", + "digest": + [56, + 118, + 177, + 96, + 43, + 93, + 235, + 100, + 88, + 15, + 33, + 237, + 5, + 20, + 59, + 29, + 31, + 252, + 48, + 167, + 172, + 182, + 79, + 5, + 187, + 186, + 208, + 249, + 215, + 189, + 60, + 215]}, + {"source": "cuda/generated/production/ix_aggr.cu", + "digest": + [24, + 101, + 237, + 242, + 158, + 249, + 245, + 232, + 166, + 63, + 111, + 28, + 0, + 56, + 123, + 184, + 114, + 20, + 52, + 208, + 65, + 78, + 164, + 255, + 58, + 80, + 48, + 202, + 177, + 221, + 75, + 114]}], + "abi": 2} diff --git a/crates/aiur/cuda/trace-manifest.json b/crates/aiur/cuda/trace-manifest.json new file mode 100644 index 000000000..43e304a38 --- /dev/null +++ b/crates/aiur/cuda/trace-manifest.json @@ -0,0 +1,70 @@ +{"units": + [{"source": "cuda/generated/fixtures.cu", + "digest": + [80, + 2, + 183, + 205, + 35, + 134, + 155, + 0, + 164, + 41, + 110, + 82, + 189, + 178, + 247, + 63, + 143, + 56, + 104, + 96, + 140, + 96, + 50, + 82, + 82, + 77, + 45, + 67, + 5, + 131, + 215, + 169]}, + {"source": "cuda/generated/blake3.cu", + "digest": + [179, + 237, + 214, + 101, + 18, + 151, + 108, + 138, + 116, + 91, + 133, + 250, + 219, + 180, + 57, + 233, + 167, + 144, + 164, + 129, + 225, + 114, + 65, + 169, + 217, + 87, + 27, + 178, + 172, + 81, + 137, + 96]}], + "abi": 2} diff --git a/crates/aiur/cuda/trace_primitives.cuh b/crates/aiur/cuda/trace_primitives.cuh new file mode 100644 index 000000000..f60c70b6a --- /dev/null +++ b/crates/aiur/cuda/trace_primitives.cuh @@ -0,0 +1,24 @@ +#pragma once +#include +#include "trace_runtime.cuh" + +namespace aiur_trace { +using namespace multi_stark_cuda; + +static __device__ __noinline__ uint64_t inverse(uint64_t value) { + return value == 0 ? 0 : goldilocks_pow(value, GOLDILOCKS_P - 2); +} + +__device__ __forceinline__ uint64_t word(uint64_t a, uint64_t b, uint64_t c, uint64_t d) { + return a | (b << 8) | (c << 16) | (d << 24); +} + +struct WordSum { uint64_t low; uint64_t carry; }; + +__device__ __forceinline__ WordSum add_words(uint64_t a, uint64_t b, uint64_t c = 0) { + const uint64_t ab = a + b; + const uint64_t low = ab + c; + const uint64_t high = uint64_t(ab < a) + uint64_t(low < ab); + return {low & 0xffffffffULL, (low >> 32) + (high << 32)}; +} +} // namespace aiur_trace diff --git a/crates/aiur/cuda/trace_runtime.cu b/crates/aiur/cuda/trace_runtime.cu new file mode 100644 index 000000000..c3213226f --- /dev/null +++ b/crates/aiur/cuda/trace_runtime.cu @@ -0,0 +1,296 @@ +#include "trace_runtime.cuh" +#include +#include +#include + +namespace aiur_trace { +namespace { +// One staging lease is a ring of pinned chunk buffers, each with the event +// of its last transfer, so a span's host copy into pinned memory overlaps +// the DMA of the chunks before it and the blanking of the output. The +// kernel still runs once over the whole span: a per-chunk launch would +// leave most of the device idle. +// +// Events belong to the device that was current when they were created, and +// recording one on another device's stream fails with +// cudaErrorInvalidResourceHandle, so every device has its own slots. The +// pinned buffers are allocated on first use, so devices that never upload +// cost nothing. +constexpr size_t RING = 8; +constexpr size_t CHUNK_BYTES = (MAX_SEED_BYTES / RING) & ~size_t(7); +constexpr int MAX_DEVICES = 64; +constexpr size_t SLOTS_PER_DEVICE = 4; + +struct Slot { + uint8_t* data = nullptr; + cudaEvent_t events[RING] = {}; + bool busy = false; +}; +Slot slots[MAX_DEVICES][SLOTS_PER_DEVICE]; +pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +pthread_cond_t ready = PTHREAD_COND_INITIALIZER; + +class Lease { + Slot* slot_ = nullptr; +public: + Lease() = default; + Lease(const Lease&) = delete; + Lease& operator=(const Lease&) = delete; + ~Lease() { + if (!slot_) return; + pthread_mutex_lock(&mutex); + slot_->busy = false; + pthread_cond_signal(&ready); + pthread_mutex_unlock(&mutex); + } + // The caller has made `device` current: the slot's events are created + // on it, and the slot only ever serves that device. + cudaError_t acquire(int device) { + if (device < 0 || device >= MAX_DEVICES) return cudaErrorInvalidDevice; + pthread_mutex_lock(&mutex); + while (!slot_) { + for (auto& slot : slots[device]) if (!slot.busy) { + slot.busy = true; + slot_ = &slot; + break; + } + if (!slot_) pthread_cond_wait(&ready, &mutex); + } + pthread_mutex_unlock(&mutex); + if (slot_->data) return cudaSuccess; + auto status = cudaHostAlloc(reinterpret_cast(&slot_->data), + STAGING_BYTES, cudaHostAllocPortable); + if (status != cudaSuccess) { + slot_->data = nullptr; + return status; + } + for (auto& event : slot_->events) { + status = cudaEventCreateWithFlags(&event, cudaEventDisableTiming); + if (status != cudaSuccess) return status; + } + return cudaSuccess; + } + uint8_t* chunk(size_t index) const { return slot_->data + index * CHUNK_BYTES; } + cudaEvent_t event(size_t index) const { return slot_->events[index]; } + uint32_t* error() const { return reinterpret_cast(slot_->data + MAX_SEED_BYTES); } +}; + +// Streams `bytes` from pageable `source` to `destination` on the calling +// thread's stream through the lease's ring, so each host copy overlaps the +// transfers before it. `chunk` counts the lease's transfers so far and is +// carried across calls: a ring slot is reused only once the transfer it +// last staged has landed, whichever span that transfer belonged to. The +// last chunks are still in flight on return. +cudaError_t stage_copy(const Lease& lease, uint8_t* destination, + const uint8_t* source, size_t bytes, size_t& chunk) { + cudaError_t status = cudaSuccess; + size_t offset = 0; + for (; status == cudaSuccess && offset < bytes; ++chunk) { + const size_t index = chunk % RING; + if (chunk >= RING) status = cudaEventSynchronize(lease.event(index)); + const size_t length = std::min(CHUNK_BYTES, bytes - offset); + if (status == cudaSuccess) { + std::memcpy(lease.chunk(index), source + offset, length); + status = cudaMemcpyAsync(destination + offset, lease.chunk(index), length, + cudaMemcpyHostToDevice, cudaStreamPerThread); + } + if (status == cudaSuccess) status = cudaEventRecord(lease.event(index), cudaStreamPerThread); + offset += length; + } + return status; +} + +bool on_device(const void* pointer, cudaError_t& status) { + cudaPointerAttributes attributes{}; + status = cudaPointerGetAttributes(&attributes, pointer); + return status == cudaSuccess && attributes.type == cudaMemoryTypeDevice; +} + +// Rows from seeds already resident on the device: no staging, no seed +// allocation, one error word for the launch. +int generate_resident(const uint8_t* seeds, uint32_t encoding, size_t real, + size_t rows, Layout layout, uint64_t* output, Launch launch) { + uint32_t* device_error = nullptr; + cudaError_t status = cudaMallocAsync(reinterpret_cast(&device_error), 4, cudaStreamPerThread); + if (status == cudaSuccess) status = cudaMemsetAsync(device_error, 0, 4, cudaStreamPerThread); + if (status == cudaSuccess) + status = cudaMemsetAsync(output, 0, rows * layout.width * 8, cudaStreamPerThread); + if (status == cudaSuccess) + status = launch(seeds, encoding, real, rows, layout, output, device_error); + uint32_t error = 0; + if (status == cudaSuccess) + status = cudaMemcpyAsync(&error, device_error, 4, cudaMemcpyDeviceToHost, cudaStreamPerThread); + if (device_error) { + const auto freed = cudaFreeAsync(device_error, cudaStreamPerThread); + if (status == cudaSuccess) status = freed; + } + // The output may cross threads immediately after return. + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + if (status != cudaSuccess) return int(status); + return error ? 10000 + int(error) : 0; +} +} // namespace + +int upload(int device, const uint8_t* seeds, uint32_t encoding, + size_t seed_stride, size_t real, size_t rows, Layout layout, + uint64_t* output, Launch launch) { + if (!output || !launch || !rows || rows > MAX_ROWS || real > rows + || !seed_stride + || real > MAX_SEED_BYTES / seed_stride || (real && !seeds) + || !layout.width || layout.width > std::numeric_limits::max() / rows / 8) + return int(cudaErrorInvalidValue); + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return int(status); + if (!real) { + status = cudaMemsetAsync(output, 0, rows * layout.width * 8, cudaStreamPerThread); + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + return int(status == cudaSuccess ? synced : status); + } + if (on_device(seeds, status)) + return generate_resident(seeds, encoding, real, rows, layout, output, launch); + if (status != cudaSuccess) return int(status); + // A lease bounds both pinned memory and live device seed allocations. + Lease lease; + status = lease.acquire(device); + if (status != cudaSuccess) return int(status); + *lease.error() = 0; + const size_t bytes = real * seed_stride; + uint8_t* device_seeds = nullptr; + status = cudaMallocAsync(reinterpret_cast(&device_seeds), bytes + 8, cudaStreamPerThread); + uint32_t* device_error = nullptr; + if (status == cudaSuccess) { + device_error = reinterpret_cast(device_seeds + bytes); + status = cudaMemsetAsync(device_error, 0, 4, cudaStreamPerThread); + } + // Kernels write only the columns a row sets. Blanking the tile here with + // coalesced stores, while the host is still copying seeds, is a third + // cheaper than a zero pass over each row inside the kernel. + if (status == cudaSuccess) + status = cudaMemsetAsync(output, 0, rows * layout.width * 8, cudaStreamPerThread); + size_t chunk = 0; + if (status == cudaSuccess) status = stage_copy(lease, device_seeds, seeds, bytes, chunk); + if (status == cudaSuccess) + status = launch(device_seeds, encoding, real, rows, layout, output, device_error); + if (status == cudaSuccess) status = cudaMemcpyAsync(lease.error(), device_error, 4, cudaMemcpyDeviceToHost, cudaStreamPerThread); + if (device_seeds) { + const auto freed = cudaFreeAsync(device_seeds, cudaStreamPerThread); + if (status == cudaSuccess) status = freed; + } + // The output and staging lease may cross threads immediately after return. + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + if (status != cudaSuccess) return int(status); + return *lease.error() ? 10000 + int(*lease.error()) : 0; +} + +extern "C" int aiur_trace_seed_cache_upload(int device, const uint8_t* const* spans, + const size_t* lengths, size_t count, size_t total, uint8_t** cached) { + if (!cached) return int(cudaErrorInvalidValue); + *cached = nullptr; + if (!spans || !lengths || !count || !total) return int(cudaErrorInvalidValue); + size_t sum = 0; + for (size_t i = 0; i < count; ++i) { + if (!spans[i] || !lengths[i] || lengths[i] > total - sum) + return int(cudaErrorInvalidValue); + sum += lengths[i]; + } + if (sum != total) return int(cudaErrorInvalidValue); + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return int(status); + uint8_t* buffer = nullptr; + status = cudaMalloc(reinterpret_cast(&buffer), total); + if (status != cudaSuccess) { + // Out of memory is an answer, not a sticky fault. + cudaGetLastError(); + return int(status); + } + Lease lease; + status = lease.acquire(device); + size_t offset = 0, chunk = 0; + for (size_t i = 0; status == cudaSuccess && i < count; ++i) { + status = stage_copy(lease, buffer + offset, spans[i], lengths[i], chunk); + offset += lengths[i]; + } + // The lease's chunks are reused as soon as it is released. + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + if (status != cudaSuccess) { + cudaFree(buffer); + return int(status); + } + *cached = buffer; + return 0; +} + +extern "C" int aiur_trace_seed_cache_free(int device, uint8_t* cached) { + if (!cached) return 0; + cudaError_t status = cudaSetDevice(device); + if (status == cudaSuccess) status = cudaFree(cached); + return int(status); +} + +// A tile of `words` u64 on `device` for a caller that drives a writer +// outside the prover and reads the rows back; `aiur_trace_tile_download` +// copies it out after the per-thread stream's work on it and frees it. +extern "C" int aiur_trace_tile_alloc(int device, size_t words, uint64_t** tile) { + if (!tile) return int(cudaErrorInvalidValue); + *tile = nullptr; + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return int(status); + status = cudaMalloc(reinterpret_cast(tile), words * sizeof(uint64_t)); + if (status != cudaSuccess) { + cudaGetLastError(); + *tile = nullptr; + } + return int(status); +} + +extern "C" int aiur_trace_tile_download(int device, uint64_t* tile, size_t words, + uint64_t* host) { + if (!tile || !host) return int(cudaErrorInvalidValue); + cudaError_t status = cudaSetDevice(device); + if (status == cudaSuccess) + status = cudaMemcpyAsync(host, tile, words * sizeof(uint64_t), + cudaMemcpyDeviceToHost, cudaStreamPerThread); + const auto synced = cudaStreamSynchronize(cudaStreamPerThread); + if (status == cudaSuccess) status = synced; + const auto freed = cudaFree(tile); + if (status == cudaSuccess) status = freed; + return int(status); +} +// Memory-table rows: `[multiplicity, 1, pointer, values...]` from seeds of +// `[multiplicity, pointer, values...]`, one thread per row. Every table row +// is real, zero multiplicities included; the padding rows keep the blank +// the uploader wrote. +namespace { +__global__ void memory_rows(const uint8_t* __restrict__ seeds, size_t real, + size_t, Layout layout, uint64_t* __restrict__ output, uint32_t*) { + const size_t r = size_t(blockIdx.x) * blockDim.x + threadIdx.x; + if (r >= real) return; + uint64_t* row = output + r * layout.width; + const size_t values = layout.width - 3; + const uint64_t* seed = + reinterpret_cast(seeds + r * (values + 2) * 8); + row[0] = seed[0]; + row[1] = 1; + row[2] = seed[1]; + for (size_t i = 0; i < values; ++i) row[3 + i] = seed[2 + i]; +} + +cudaError_t launch_memory(const uint8_t* seeds, uint32_t, size_t real, + size_t rows, Layout layout, uint64_t* output, uint32_t* error) { + memory_rows<<>>( + seeds, real, rows, layout, output, error); + return cudaGetLastError(); +} +} // namespace + +extern "C" int aiur_trace_memory(int device, const uint8_t* seeds, + size_t values, size_t real, size_t rows, uint64_t* output) { + if (values > std::numeric_limits::max() / 8 - 3) + return int(cudaErrorInvalidValue); + return upload(device, seeds, 0, (values + 2) * 8, real, rows, + {values + 3, 0, 0}, output, launch_memory); +} +} // namespace aiur_trace diff --git a/crates/aiur/cuda/trace_runtime.cuh b/crates/aiur/cuda/trace_runtime.cuh new file mode 100644 index 000000000..2215e13c4 --- /dev/null +++ b/crates/aiur/cuda/trace_runtime.cuh @@ -0,0 +1,58 @@ +#pragma once +#include +#include +#include +#include + +namespace aiur_trace { +constexpr size_t STAGING_BYTES = 16 * 1024 * 1024; +constexpr size_t MAX_SEED_BYTES = STAGING_BYTES - 8; +constexpr size_t MAX_ROWS = 65537; +constexpr uint32_t ABI_VERSION = 2; + +struct Layout { + size_t width; + size_t selectors; + size_t auxiliaries; +}; + +// Typed seed words are naturally aligned: the host lays wider words out +// first and pads every stride to a multiple of eight. +__device__ __forceinline__ uint64_t load_u8(const uint8_t* p) { return *p; } +__device__ __forceinline__ uint64_t load_u16(const uint8_t* p) { + return *reinterpret_cast(p); +} +__device__ __forceinline__ uint64_t load_u32(const uint8_t* p) { + return *reinterpret_cast(p); +} +__device__ __forceinline__ uint64_t load_u64(const uint8_t* p) { + return *reinterpret_cast(p); +} + +using Launch = cudaError_t (*)(const uint8_t*, uint32_t, size_t, size_t, + Layout, uint64_t*, uint32_t*); + +// `seed_stride` is the byte stride of `encoding` for this function; the +// generated entry point resolves it, since typed strides differ per function. +// `output` is blanked before `launch` runs, so a kernel writes only the +// columns of the first `real` rows that are set. `seeds` is either host +// memory, staged through pinned chunks for this call, or device memory +// from `aiur_trace_seed_cache_upload`, which the kernel reads directly. +int upload(int device, const uint8_t* seeds, uint32_t encoding, + size_t seed_stride, size_t real, size_t rows, Layout layout, + uint64_t* output, Launch launch); +} // namespace aiur_trace + +extern "C" { +// Copies `count` host seed spans back to back into one new device +// allocation of `total` bytes on `device` and returns it in `cached`. A +// failed allocation returns its status with `cached` null, so the caller +// can keep serving from the host. +int aiur_trace_seed_cache_upload(int device, const uint8_t* const* spans, + const size_t* lengths, size_t count, size_t total, uint8_t** cached); +int aiur_trace_seed_cache_free(int device, uint8_t* cached); +// A device tile for driving a writer outside the prover; the download copies +// it to `host` after the per-thread stream's work on it and frees it. +int aiur_trace_tile_alloc(int device, size_t words, uint64_t** tile); +int aiur_trace_tile_download(int device, uint64_t* tile, size_t words, uint64_t* host); +} diff --git a/crates/aiur/src/gpu_trace/mod.rs b/crates/aiur/src/gpu_trace/mod.rs new file mode 100644 index 000000000..74c169ca3 --- /dev/null +++ b/crates/aiur/src/gpu_trace/mod.rs @@ -0,0 +1,149 @@ +//! Selection of the main-trace provider for GPU proving. +//! +//! The CPU builder is always available. The generated provider is compiled +//! from bytecode by `ix codegen --trace-bundle` and covers the circuits its +//! registry lists; every other circuit falls back to CPU rows. + +use std::sync::Arc; + +use multi_stark::{lookup::LookupValues, witness::TraceSource}; + +use crate::{ + G, + bytecode::Toplevel, + execute::{IOBuffer, QueryRecord}, + trace::QueryPosition, +}; + +pub(crate) enum TraceProvider { + Cpu, + #[cfg(feature = "cuda-trace-codegen")] + Generated(crate::trace_codegen::cuda::RegisteredCudaProgram), +} + +impl TraceProvider { + pub(crate) fn from_env(_top: Arc) -> Self { + let mode = std::env::var("AIUR_GPU_TRACE").unwrap_or_else(|_| "cpu".into()); + if mode != "cpu" { + assert!( + crate::trace::trace_only_lookups(), + "AIUR_GPU_TRACE={mode} requires AIUR_TRACE_ONLY_LOOKUPS=1" + ); + } + match mode.as_str() { + "cpu" => Self::Cpu, + #[cfg(feature = "cuda-trace-codegen")] + "generated" => Self::Generated( + crate::trace_codegen::programs::register(_top) + .unwrap_or_else(|error| panic!("AIUR_GPU_TRACE=generated: {error}")), + ), + #[cfg(not(feature = "cuda-trace-codegen"))] + "generated" => panic!( + "AIUR_GPU_TRACE=generated requires the cuda-trace-codegen feature (IX_CUDA_TRACE_CODEGEN=1)" + ), + _ => panic!("unsupported AIUR_GPU_TRACE={mode}; use cpu or generated"), + } + } + + /// A memory table range on the device; `None` leaves it to the CPU builder. + /// + /// Opt-in through `AIUR_GPU_TRACE_MEMORY=1`: a memory seed is the row minus + /// one column, so generation moves as many bytes as the CPU trace and adds + /// a launch per span, which made it a net loss where it was measured. It + /// stays available for workloads where the host builder, not transport, + /// is the limit. + pub(crate) fn prepare_memory( + &self, + _record: &QueryRecord, + _size: usize, + _slots: &[usize], + _range: std::ops::Range, + ) -> Option<(TraceSource, LookupValues)> { + match self { + Self::Cpu => None, + #[cfg(feature = "cuda-trace-codegen")] + Self::Generated(_) => { + if std::env::var("AIUR_GPU_TRACE_MEMORY").as_deref() != Ok("1") { + return None; + } + match crate::trace_codegen::cuda::prepare_memory( + _record, + _size, + _slots, + _range.clone(), + ) { + Ok(prepared) => Some(prepared), + Err(error) => { + tracing::warn!( + size = _size, + rows = _range.len(), + %error, + "CPU trace: generated memory seed preparation failed" + ); + None + }, + } + }, + } + } + + /// `None` leaves the circuit to the CPU trace builder. With + /// `retain_device_seeds` the source keeps its seeds on the device from its + /// first tile until the backend releases them, so the lookup pass + /// regenerates rows without the host. + pub(crate) fn prepare( + &self, + _top: &Toplevel, + _circuit: usize, + _record: &QueryRecord, + _io: &IOBuffer, + _slots: &[usize], + _start: QueryPosition, + _end: QueryPosition, + _row_count: usize, + _retain_device_seeds: bool, + ) -> Option<(TraceSource, LookupValues)> { + match self { + Self::Cpu => None, + #[cfg(feature = "cuda-trace-codegen")] + Self::Generated(program) => { + if _row_count == 0 { + return None; + } + let bound = program.bound(); + if !bound.supports(_circuit) { + tracing::debug!( + circuit = _circuit, + rows = _row_count, + "CPU trace: circuit lacks generated CUDA coverage" + ); + return None; + } + // A preparation error means the record disagrees with the generated + // packer or a resource ran out; the CPU builder is the reference, so + // fall back to it and say so rather than abort the proof. + match bound.prepare( + _circuit, + _record, + _io, + _slots, + _start, + _end, + _row_count, + _retain_device_seeds, + ) { + Ok(prepared) => Some(prepared), + Err(error) => { + tracing::warn!( + circuit = _circuit, + rows = _row_count, + %error, + "CPU trace: generated seed preparation failed" + ); + None + }, + } + }, + } + } +} diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs index da484aba1..8e654ecc1 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -13,6 +13,7 @@ mod row_counts; pub mod shard; pub mod synthesis; pub mod trace; +pub mod trace_codegen; mod trace_heights; pub mod vk_codec; @@ -116,3 +117,6 @@ pub fn u16_range_check_channel() -> G { pub fn memseg_channel() -> G { G::from_u8(16) } + +#[cfg(feature = "cuda")] +pub mod gpu_trace; diff --git a/crates/aiur/src/shard.rs b/crates/aiur/src/shard.rs index b34c38bad..495138b46 100644 --- a/crates/aiur/src/shard.rs +++ b/crates/aiur/src/shard.rs @@ -67,7 +67,6 @@ use std::ops::Range; use multi_stark::{ batch::{BatchMessage, BatchPreamble, BatchProof, Retention}, p3_field::{Field, PrimeCharacteristicRing, PrimeField64}, - p3_matrix::Matrix, system::SystemWitness, }; use rayon::iter::{ @@ -344,6 +343,50 @@ impl AiurSystem { index: &RowIndex, shard: usize, ) -> SystemWitness { + let witness = + self.prepare_shard_witness(record, io_buffer, plan, index, shard, None); + SystemWitness { + traces: witness + .traces + .into_iter() + .map(|source| source.materialize()) + .collect(), + lookups: witness.lookups, + } + } + + /// Prepares host traces and compact accelerator sources without allocating + /// on the GPU, for the batch round the witness feeds. + pub fn prepared_shard_witness( + &self, + record: &QueryRecord, + io_buffer: &IOBuffer, + plan: &ShardPlan, + index: &RowIndex, + shard: usize, + round: BatchRound, + ) -> multi_stark::witness::PreparedWitness { + self.prepare_shard_witness( + record, + io_buffer, + plan, + index, + shard, + Some(round), + ) + } + + /// `generated` is the round a witness with device sources feeds; `None` + /// builds every circuit on the host. + fn prepare_shard_witness( + &self, + record: &QueryRecord, + io_buffer: &IOBuffer, + plan: &ShardPlan, + index: &RowIndex, + shard: usize, + _generated: Option, + ) -> multi_stark::witness::PreparedWitness { let circuit_types = self.circuit_types(); let ranges = &plan.shards[shard].rows; assert_eq!(ranges.len(), circuit_types.len(), "plan/system circuit count"); @@ -357,6 +400,38 @@ impl AiurSystem { let _witness = witness_span.enter(); let slot_arg_widths = self.slot_arg_widths(circuit_idx); let range = ranges[circuit_idx].clone(); + #[cfg(feature = "cuda")] + if let Some(round) = _generated { + match circuit_type { + CircuitType::Function { idx } => { + let (start, end) = index.queries(circuit_idx, &range); + if let Some(prepared) = self.trace_provider.prepare( + self.toplevel(), + idx, + record, + io_buffer, + &slot_arg_widths, + start, + end, + range.len(), + round == BatchRound::Two, + ) { + return prepared; + } + }, + CircuitType::Memory { width } if !range.is_empty() => { + if let Some(prepared) = self.trace_provider.prepare_memory( + record, + width, + &slot_arg_widths, + range.clone(), + ) { + return prepared; + } + }, + _ => {}, + } + } let kind = match circuit_type { CircuitType::Function { .. } => "function", CircuitType::Memory { .. } => "memory", @@ -370,7 +445,6 @@ impl AiurSystem { rows = range.len() ) .entered(); - let real_rows = range.len(); let (trace, lookups) = match circuit_type { CircuitType::Function { idx } => { let (start, end) = index.queries(circuit_idx, &range); @@ -399,15 +473,11 @@ impl AiurSystem { Bytes2.witness_data(source, &slot_arg_widths) }, }; - tracing::info!(target: "prover_metrics", metric = "trace", - circuit = circuit_idx, provider = "cpu", kind, - rows = real_rows, height = trace.height(), width = trace.width(), - padded_cells = trace.height().saturating_mul(trace.width())); - (trace, lookups) + (multi_stark::witness::TraceSource::Host(trace), lookups) }) .collect::>(); let (traces, lookups) = witness_data.into_iter().unzip(); - SystemWitness { traces, lookups } + multi_stark::witness::PreparedWitness { traces, lookups } } /// The projected prover peak of shard `shard` of `plan` with the record diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 0fdd9d679..a3f0a2ef1 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -166,8 +166,12 @@ pub struct PreparedProve { } pub struct AiurSystem { - toplevel: Toplevel, + /// Shared with the systems [`Self::on_device`] derives for other GPUs, + /// so the bytecode crosses the FFI once and is never copied. + toplevel: std::sync::Arc, claim_shapes: Vec>, + #[cfg(feature = "cuda")] + pub(crate) trace_provider: std::sync::Arc, // perhaps remove the key from the system in verifier only mode? key: ProverKey, /// The parameters the system's config was built from, kept for the @@ -264,10 +268,55 @@ impl AiurSystem { toplevel: Toplevel, commitment_parameters: CommitmentParameters, fri_parameters: FriParameters, + ) -> Self { + #[cfg(not(feature = "cuda"))] + assert!( + std::env::var("AIUR_GPU_TRACE").as_deref() != Ok("generated"), + "AIUR_GPU_TRACE=generated requires the cuda-trace-codegen feature (IX_CUDA_TRACE_CODEGEN=1)" + ); + Self::build_on_device( + std::sync::Arc::new(toplevel), + commitment_parameters, + fri_parameters, + None, + #[cfg(feature = "cuda")] + None, + ) + } + + /// The same system with its prover on CUDA device `device_id`, sharing + /// this one's bytecode; only the device-bound parts (the configuration, + /// the prover key, the circuit system) are rebuilt. What lets one + /// process hold a prover per GPU. + pub fn on_device(&self, device_id: i32) -> Self { + Self::build_on_device( + std::sync::Arc::clone(&self.toplevel), + self.commitment_parameters, + self.fri_parameters, + Some(device_id), + #[cfg(feature = "cuda")] + Some(std::sync::Arc::clone(&self.trace_provider)), + ) + } + + fn build_on_device( + toplevel: std::sync::Arc, + commitment_parameters: CommitmentParameters, + fri_parameters: FriParameters, + device_id: Option, + #[cfg(feature = "cuda")] trace_provider: Option< + std::sync::Arc, + >, ) -> Self { let claim_shapes = toplevel.checked_claim_shapes().expect("invalid Aiur lookup shapes"); toplevel.validate_row_counts().expect("invalid Aiur control counts"); + #[cfg(feature = "cuda")] + let trace_provider = trace_provider.unwrap_or_else(|| { + std::sync::Arc::new(crate::gpu_trace::TraceProvider::from_env( + toplevel.clone(), + )) + }); let mut circuit_inputs: Vec> = Vec::new(); let mut slot_widths: Vec> = Vec::new(); @@ -335,7 +384,8 @@ impl AiurSystem { 2, ); - let config = AiurConfig::new(commitment_parameters, fri_parameters); + let config = + AiurConfig::with_device(commitment_parameters, fri_parameters, device_id); let (mut system, key) = System::new(config, circuit_inputs); let blowup = system.config.max_quotient_degree(); for circuit in &mut system.circuits { @@ -357,6 +407,8 @@ impl AiurSystem { key, toplevel, claim_shapes, + #[cfg(feature = "cuda")] + trace_provider, commitment_parameters, fri_parameters, slot_widths, @@ -641,6 +693,7 @@ impl AiurSystem { O: FnOnce() -> Vec, S: FnMut(usize) -> Result, String>, { + #[cfg(feature = "texray")] tracing_texray::examine_current(); if count == 0 { return Err("no records to prove".into()); @@ -685,12 +738,13 @@ impl AiurSystem { round = 1 ) .entered(); - let witness = self.shard_witness( + let witness = self.prepared_shard_witness( supplied.record(), supplied.io(), plan, &indexes[*r], s, + BatchRound::One, ); return Some((claims, witness)); } @@ -766,12 +820,13 @@ impl AiurSystem { round = 2 ) .entered(); - self.shard_witness( + self.prepared_shard_witness( supplied.record(), supplied.io(), &plans[r], &indexes[r], s, + BatchRound::Two, ) }); Ok((claim, proof)) @@ -852,7 +907,14 @@ impl AiurSystem { }; let _g = tracing::info_span!("aiur/witness", shard, round = round_number) .entered(); - self.shard_witness(&query_record, io_buffer, plan, &index, shard) + self.prepared_shard_witness( + &query_record, + io_buffer, + plan, + &index, + shard, + round, + ) }; let proof = match retention { // A retained stage 1 is committed once and serves round two's lookups. @@ -891,6 +953,7 @@ impl AiurSystem { input: &[G], io_buffer: &mut IOBuffer, ) -> (Vec, AiurProof) { + #[cfg(feature = "texray")] tracing_texray::examine_current(); // Execute the Aiur bytecode. @@ -984,6 +1047,7 @@ impl AiurSystem { &mut IOBuffer, ) -> Result<(QueryRecord, Vec), ExecError>, { + #[cfg(feature = "texray")] tracing_texray::examine_current(); let prepared = match self.prepare_ixvm_within_budget( fun_idx, @@ -1350,6 +1414,144 @@ mod tests { assert_eq!(calibrate_prover_rss(usize::MAX), usize::MAX); } + #[cfg(feature = "cuda-trace-codegen")] + #[test] + fn codegen_blake3_regenerated_batch_matches_cpu() { + use multi_stark::p3_matrix::Matrix; + use multi_stark::witness::{PreparedWitness, TraceSource}; + let (cp, fp) = test_parameters(); + let program = (crate::trace_codegen::tests::blake3::PROGRAM.expected)(); + let mut system = AiurSystem::build(program, cp, fp); + let provider = crate::gpu_trace::TraceProvider::Generated( + crate::trace_codegen::tests::blake3_cuda::CUDA + .register( + &crate::trace_codegen::tests::blake3::PROGRAM, + system.toplevel.clone(), + ) + .unwrap(), + ); + system.trace_provider = std::sync::Arc::new(provider); + let other = system.on_device(0); + assert!(std::sync::Arc::ptr_eq( + &system.trace_provider, + &other.trace_provider, + )); + let mut io = empty_io_buffer(); + let mut input = vec![G::ZERO]; + input.extend((0..128).map(|i| G::from_usize((i * 37 + 19) % 256))); + let (record, output) = + system.toplevel().execute(0, input.clone(), &mut io).unwrap(); + let mut plan = system.plan_shards(&record, None); + assert_eq!(plan.num_shards(), 1); + assert_eq!(plan.shards[0].rows[0], 0..8); + plan.shards[0].rows[0] = 0..4; + plan.shards.push(ShardRows { rows: vec![4..8, 0..0, 0..0] }); + let index = system.row_index(&record, &plan); + let mut claim = vec![function_channel(), G::ZERO]; + claim.extend(input); + claim.extend(output); + let claims = vec![vec![claim.clone()], vec![]]; + let build = |shard: usize, + round: Option| + -> PreparedWitness { + match round { + Some(round) => system + .prepared_shard_witness(&record, &io, &plan, &index, shard, round), + None => system.shard_witness(&record, &io, &plan, &index, shard).into(), + } + }; + let witness = build(0, Some(BatchRound::Two)); + let TraceSource::Generated(source) = &witness.traces[0] else { + panic!("missing GPU source") + }; + let weak_source = std::sync::Arc::downgrade(source); + let stage1 = system.system.prove_stage_1(witness); + drop(stage1); + assert!( + weak_source.upgrade().is_none(), + "released stage one retained a generated source or LDE" + ); + + let reference = system.system.prove_batch_with( + &system.key, + &claims, + vec![], + Retention::Regenerate, + |shard| build(shard, None), + ); + system.verify(&claim, &reference).unwrap(); + // Round one keeps no seeds on the device; round two's two generated + // sources upload theirs once each and the lookup pass releases them. + use crate::trace_codegen::cuda::{SEED_CACHE_UPLOADS, seed_cache_bytes}; + use std::sync::atomic::Ordering; + let uploads = SEED_CACHE_UPLOADS.load(Ordering::Acquire); + let witnesses: Vec<_> = (0..claims.len()) + .map(|shard| build(shard, Some(BatchRound::One))) + .collect(); + let sources: Vec<_> = witnesses + .iter() + .flat_map(|witness| &witness.traces) + .filter_map(|trace| match trace { + TraceSource::Generated(source) => { + Some(std::sync::Arc::downgrade(source)) + }, + TraceSource::Host(_) => None, + }) + .collect(); + let barrier = system.system.batch_round_one( + claims.iter().cloned().zip(witnesses), + Retention::Regenerate, + ); + assert!( + sources.iter().all(|source| source.upgrade().is_none()), + "round one retained a generated source or LDE across the barrier" + ); + assert_eq!(SEED_CACHE_UPLOADS.load(Ordering::Acquire), uploads); + let proof = + system.system.batch_round_two(&system.key, barrier, vec![], |shard| { + build(shard, Some(BatchRound::Two)) + }); + assert_eq!(SEED_CACHE_UPLOADS.load(Ordering::Acquire), uploads + 2); + assert_eq!(seed_cache_bytes(0), 0, "round two released its seeds"); + system.verify(&claim, &proof).unwrap(); + assert_eq!( + proof.to_bytes().unwrap(), + reference.to_bytes().unwrap(), + "GPU generation changed proof bytes" + ); + let corrupt = || { + let mut witness = build(0, Some(BatchRound::Two)); + let source = witness.traces.remove(0); + let mut trace = source.materialize(); + let row = (0..trace.height()) + .find(|&r| trace.values[r * 533] != G::from_u8(7)) + .unwrap(); + // This auxiliary supplies both the recursive call and its returned value. + trace.values[row * 533 + 501] += G::ONE; + witness.traces.insert(0, TraceSource::Host(trace)); + witness + }; + let fresh = system.system.prove_stage_1(corrupt()); + assert_ne!( + fresh.stage_1_trace_commit, reference.preamble.headers[0].stage_1_trace, + "independent commitment must detect incorrect regeneration" + ); + drop(fresh); + let barrier = system.system.batch_round_one( + claims + .iter() + .enumerate() + .map(|(shard, c)| (c.clone(), build(shard, Some(BatchRound::One)))), + Retention::Regenerate, + ); + let bad = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + system.system.batch_round_two(&system.key, barrier, vec![], |shard| { + if shard == 0 { corrupt() } else { build(shard, Some(BatchRound::Two)) } + }) + })); + assert!(bad.is_err(), "round two must reject corrupted regenerated values"); + } + /// Small FRI parameters mirroring `vk_codec`'s test config: cheap to prove /// while still exercising the full FRI pipeline (log_blowup 1, 64 queries, /// no proof-of-work). @@ -1597,6 +1799,68 @@ mod tests { ); } + #[cfg(feature = "cuda")] + #[test] + fn record_pool_workspace_excludes_shape_only_lookup_payloads() { + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); + let record = QueryRecord::new(system.toplevel()); + let mut plan = system.single_shard_plan(&record); + plan.shards[0].rows[0] = 0..(1 << 20); + let full = system.shard_host_workspace(&plan, 0, true); + let shape_only = system.shard_host_workspace(&plan, 0, false); + assert!(shape_only < 512 << 20, "shape-only workspace: {shape_only}"); + assert!(full > 512 << 20, "materialized lookup workspace: {full}"); + } + + #[cfg(feature = "cuda")] + #[test] + #[ignore = "requires two CUDA devices"] + fn record_pool_prepared_moves_between_devices() { + use crate::execute::bind_record_reservation; + use crate::record_pool::{ProverBudget, RecordPool}; + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); + let producer = system.on_device(0); + let consumer = system.on_device(1); + assert_eq!( + crate::vk_codec::aiur_system_to_bytes(&producer).unwrap(), + crate::vk_codec::aiur_system_to_bytes(&consumer).unwrap() + ); + let pool = RecordPool::for_provers( + 4096, + 4096, + ProverBudget { trace_cells: 1_000_000, host_workspace: 1 << 30 }, + ); + let reservation = pool.try_admit().unwrap().unwrap(); + let binding = bind_record_reservation(&reservation); + let input = [G::from_u64(3), G::from_u64(5)]; + let prepared = producer + .prepare_ixvm_within_budget( + 0, + &input, + &mut empty_io_buffer(), + |top, fun, input, io| top.execute(fun, input, io), + Some(1), + true, + None, + ) + .unwrap_or_else(|_| { + panic!("pooled planning used the obsolete per-record ceiling") + }); + let retained = crate::execute::record_retained_bytes(&prepared.record); + assert_eq!(pool.stats().reserved, retained); + drop(binding); + drop(reservation); + assert_eq!(pool.stats().reserved, retained); + let (claim, proof, _) = + std::thread::spawn(move || consumer.prove_prepared(prepared)) + .join() + .unwrap(); + assert_eq!(pool.stats().reserved, 0); + system.verify(&claim, &proof).unwrap(); + } + /// Exercise promotion of a cached unconstrained call through nested calls. /// /// `f` first computes `g(x)` as an unconstrained hint, then calls `g(x)` diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index e867b0a50..9035f280c 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -147,6 +147,49 @@ pub(crate) fn witness_metadata_bytes(members: usize, rows: usize) -> usize { pub type QueryPosition = (usize, usize); impl Toplevel { + #[cfg(test)] + pub(crate) fn main_row_for_test( + &self, + circuit_index: usize, + member: usize, + query: usize, + record: &QueryRecord, + io: &IOBuffer, + ) -> Vec { + let circuit = &self.circuits[circuit_index]; + let function = &self.functions[member]; + let offset: usize = circuit + .members + .iter() + .take_while(|&&i| i != member) + .map(|&i| self.functions[i].layout.selectors) + .sum(); + assert!(circuit.members.contains(&member)); + let (inputs, result) = + record.function_queries[member].get_index(query).unwrap(); + let mut row = vec![G::ZERO; circuit.layout.width()]; + let mut slice = ColumnMutSlice::from_slice( + function, + &circuit.layout, + offset, + &mut row, + None, + ); + function.populate_row( + &mut ColumnIndex { auxiliary: 0, lookup: 1 }, + &mut slice, + TraceContext { + function_index: G::from_usize(member), + multiplicity: result.multiplicity, + inputs, + output: result.output, + query_record: record, + }, + io, + ); + row + } + /// The number of rows function circuit `circuit_index` contributes: its /// members' queries with a nonzero multiplicity, in member order then /// record order. The unit [`Self::witness_data_range`] indexes. diff --git a/crates/aiur/src/trace_codegen.rs b/crates/aiur/src/trace_codegen.rs new file mode 100644 index 000000000..7adc4d158 --- /dev/null +++ b/crates/aiur/src/trace_codegen.rs @@ -0,0 +1,798 @@ +//! Read-only seed preparation and canonical scalar rows for generated traces. +//! +//! Binding compares the complete bytecode library, including unconstrained +//! callees. Function numbers and widths alone do not identify a row writer. + +pub mod contract; +#[cfg(feature = "cuda-trace-codegen")] +pub mod cuda; +#[cfg(feature = "cuda-trace-codegen")] +pub(crate) mod programs; + +use std::fmt; + +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; + +use crate::{ + G, + bytecode::{Block, Ctrl, FunctionLayout, Toplevel}, + execute::{IOBuffer, QueryRecord, find_unconstrained_big_uint_div_mod}, +}; + +#[derive(Debug, PartialEq, Eq)] +pub struct TraceError { + pub function: usize, + pub query: Option, + pub operation: Option, + pub detail: String, +} + +impl fmt::Display for TraceError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "trace function {}", self.function)?; + if let Some(query) = self.query { + write!(f, " query {query}")?; + } + if let Some(operation) = self.operation { + write!(f, " operation {operation}")?; + } + write!(f, ": {}", self.detail) + } +} + +impl std::error::Error for TraceError {} + +pub type TraceResult = Result; + +pub fn error( + function: usize, + operation: Option, + detail: impl Into, +) -> TraceError { + TraceError { function, query: None, operation, detail: detail.into() } +} + +pub fn no_match(function: usize, value: G) -> TraceError { + error(function, None, format!("no match for {}", value.as_canonical_u64())) +} + +/// Borrows the finalized record and I/O for one row. No helper inserts a query +/// or changes its multiplicity. The owner must retain both across regeneration. +pub struct SeedContext<'a> { + pub inputs: &'a [G], + pub output: &'a [G], + pub multiplicity: G, + record: &'a QueryRecord, + io: &'a IOBuffer, + function: usize, +} + +impl SeedContext<'_> { + fn fail(&self, operation: usize, detail: impl Into) -> TraceError { + error(self.function, Some(operation), detail) + } + + pub fn call( + &self, + operation: usize, + callee: usize, + args: &[G], + ) -> TraceResult<[G; N]> { + let result = self + .record + .function_queries + .get(callee) + .and_then(|queries| queries.get(args)) + .ok_or_else(|| { + self.fail(operation, format!("missing call to function {callee}")) + })?; + result.output.try_into().map_err(|e| { + self.fail(operation, format!("call output arity is not {N}: {e}")) + }) + } + + pub fn returned( + &self, + operation: usize, + ) -> TraceResult<[G; N]> { + self.output.try_into().map_err(|e| { + self.fail(operation, format!("returned-call arity is not {N}: {e}")) + }) + } + + pub fn store(&self, operation: usize, values: &[G]) -> TraceResult<[G; 1]> { + let index = self + .record + .memory_queries + .get(&values.len()) + .and_then(|table| table.get_index_of(values)) + .ok_or_else(|| self.fail(operation, "missing stored values"))?; + let pointer = self + .record + .pointer_base + .checked_add(index) + .ok_or_else(|| self.fail(operation, "memory pointer overflow"))?; + Ok([G::from_usize(pointer)]) + } + + pub fn load( + &self, + operation: usize, + pointer: G, + ) -> TraceResult<[G; N]> { + let index = usize::try_from(pointer.as_canonical_u64()) + .ok() + .and_then(|pointer| pointer.checked_sub(self.record.pointer_base)) + .ok_or_else(|| { + self.fail(operation, "pointer precedes this record's memory namespace") + })?; + let (values, _) = self + .record + .memory_queries + .get(&N) + .and_then(|table| table.get_index(index)) + .ok_or_else(|| self.fail(operation, "missing loaded values"))?; + values.try_into().map_err(|e| { + self.fail(operation, format!("memory width is not {N}: {e}")) + }) + } + + pub fn io_info( + &self, + operation: usize, + channel: G, + key: &[G], + ) -> TraceResult<[G; 2]> { + let info = self + .io + .get_info(channel, key) + .map_err(|e| self.fail(operation, e.to_string()))?; + Ok([G::from_usize(info.idx), G::from_usize(info.len)]) + } + + pub fn io_read( + &self, + operation: usize, + channel: G, + index: G, + ) -> TraceResult<[G; N]> { + let index = usize::try_from(index.as_canonical_u64()) + .map_err(|e| self.fail(operation, format!("I/O index overflow: {e}")))?; + self + .io + .read(channel, index, N) + .map_err(|e| self.fail(operation, e.to_string()))? + .try_into() + .map_err(|e| self.fail(operation, format!("I/O length is not {N}: {e}"))) + } + + pub fn big_uint(&self, operation: usize, a: G, b: G) -> TraceResult<[G; 2]> { + let (q, r) = find_unconstrained_big_uint_div_mod( + a, + b, + &self.record.memory_queries, + self.record.pointer_base, + ) + .map_err(|e| self.fail(operation, e))?; + Ok([q, r]) + } +} + +#[derive(Clone, Copy)] +pub struct RowOffsets { + pub selectors: usize, + pub auxiliaries: usize, +} + +/// Storage of one seed word in the typed encoding. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SeedWidth { + U8, + U16, + U32, + Full, +} + +impl SeedWidth { + pub const fn bytes(self) -> usize { + match self { + Self::U8 => 1, + Self::U16 => 2, + Self::U32 => 4, + Self::Full => 8, + } + } + + /// Whether a canonical value is representable at this width. + pub fn fits(self, value: u64) -> bool { + self == Self::Full || value >> (8 * self.bytes()) == 0 + } +} + +/// The compiler's per-word widths and byte offsets for one function's typed +/// seed. Word 0, the multiplicity, is full width at offset zero; wider words +/// precede narrower ones so every word is naturally aligned. +pub struct SeedSchema { + pub widths: &'static [SeedWidth], + pub offsets: &'static [usize], + pub bytes: usize, +} + +#[derive(Clone, Copy)] +struct InputRun { + first: usize, + len: usize, + width: SeedWidth, + offset: usize, +} + +impl SeedSchema { + /// Whether the offsets are the layout these widths dictate. + pub fn is_consistent(&self) -> bool { + if self.widths.len() != self.offsets.len() + || self.widths.first() != Some(&SeedWidth::Full) + { + return false; + } + let mut cursor = 0; + for width in + [SeedWidth::Full, SeedWidth::U32, SeedWidth::U16, SeedWidth::U8] + { + for (&candidate, &offset) in self.widths.iter().zip(self.offsets) { + if candidate == width { + if offset != cursor { + return false; + } + cursor += width.bytes(); + } + } + } + self.bytes == cursor.div_ceil(8) * 8 + } + + /// Whether the typed encoding is byte-for-byte the canonical one. + pub fn is_canonical(&self) -> bool { + self.widths.iter().all(|&width| width == SeedWidth::Full) + } + + /// Maximal runs of consecutive inputs sharing a width at contiguous + /// offsets. Each run packs as one loop, which vectorizes; per-word stores + /// with a width dispatch cost more than the record lookups they precede. + fn input_runs(&self, inputs: usize) -> Vec { + let mut runs: Vec = Vec::new(); + for input in 0..inputs { + let (width, offset) = (self.widths[1 + input], self.offsets[1 + input]); + if let Some(run) = runs.last_mut() + && run.width == width + && run.offset + run.len * width.bytes() == offset + { + run.len += 1; + continue; + } + runs.push(InputRun { first: input, len: 1, width, offset }); + } + runs + } + + fn store(bytes: &mut [u8], offset: usize, width: SeedWidth, value: u64) { + let le = value.to_le_bytes(); + bytes[offset..offset + width.bytes()].copy_from_slice(&le[..width.bytes()]); + } + + fn load(bytes: &[u8], offset: usize, width: SeedWidth) -> u64 { + let mut le = [0; 8]; + le[..width.bytes()].copy_from_slice(&bytes[offset..offset + width.bytes()]); + u64::from_le_bytes(le) + } + + /// Fails when a word exceeds its width; the caller then packs full width. + pub fn encode( + &self, + words: &[u64], + bytes: &mut [u8], + ) -> Result<(), &'static str> { + if words.len() != self.widths.len() || bytes.len() != self.bytes { + return Err("typed seed width mismatch"); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + bytes.fill(0); + for ((&word, &width), &offset) in + words.iter().zip(self.widths).zip(self.offsets) + { + if !width.fits(word) { + return Err("seed word exceeds its typed width"); + } + Self::store(bytes, offset, width, word); + } + Ok(()) + } + + pub fn decode( + &self, + bytes: &[u8], + words: &mut [u64], + ) -> Result<(), &'static str> { + if words.len() != self.widths.len() || bytes.len() != self.bytes { + return Err("typed seed width mismatch"); + } + let mut used = 0; + for ((word, &width), &offset) in + words.iter_mut().zip(self.widths).zip(self.offsets) + { + *word = Self::load(bytes, offset, width); + used = used.max(offset + width.bytes()); + } + if bytes[used..].iter().any(|&byte| byte != 0) { + return Err("nonzero seed padding"); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + Ok(()) + } +} + +/// A typed seed under construction. Narrow setters record any value that +/// exceeds its width; the caller must then discard the payload and pack the +/// row full width instead. The generated packer calls these with literal +/// offsets, so each is one store and one shift. +pub struct TypedSeed<'a> { + bytes: &'a mut [u8], + overflow: u64, +} + +#[allow(clippy::cast_possible_truncation)] +impl TypedSeed<'_> { + #[inline] + pub fn u8(&mut self, offset: usize, value: G) { + let value = value.as_canonical_u64(); + self.overflow |= value >> 8; + self.bytes[offset] = value as u8; + } + + #[inline] + pub fn u16(&mut self, offset: usize, value: G) { + let value = value.as_canonical_u64(); + self.overflow |= value >> 16; + self.bytes[offset..offset + 2] + .copy_from_slice(&(value as u16).to_le_bytes()); + } + + #[inline] + pub fn u32(&mut self, offset: usize, value: G) { + let value = value.as_canonical_u64(); + self.overflow |= value >> 32; + self.bytes[offset..offset + 4] + .copy_from_slice(&(value as u32).to_le_bytes()); + } + + #[inline] + pub fn full(&mut self, offset: usize, value: G) { + self.bytes[offset..offset + 8] + .copy_from_slice(&value.as_canonical_u64().to_le_bytes()); + } + + fn run(&mut self, run: InputRun, inputs: &[G]) { + let values = &inputs[run.first..run.first + run.len]; + let bytes = + &mut self.bytes[run.offset..run.offset + run.len * run.width.bytes()]; + let mut overflow = 0; + match run.width { + SeedWidth::U8 => { + for (dst, value) in bytes.iter_mut().zip(values) { + let value = value.as_canonical_u64(); + overflow |= value >> 8; + *dst = value as u8; + } + }, + SeedWidth::U16 => { + for (dst, value) in bytes.as_chunks_mut::<2>().0.iter_mut().zip(values) + { + let value = value.as_canonical_u64(); + overflow |= value >> 16; + dst.copy_from_slice(&(value as u16).to_le_bytes()); + } + }, + SeedWidth::U32 => { + for (dst, value) in bytes.as_chunks_mut::<4>().0.iter_mut().zip(values) + { + let value = value.as_canonical_u64(); + overflow |= value >> 32; + dst.copy_from_slice(&(value as u32).to_le_bytes()); + } + }, + SeedWidth::Full => { + for (dst, value) in bytes.as_chunks_mut::<8>().0.iter_mut().zip(values) + { + dst.copy_from_slice(&value.as_canonical_u64().to_le_bytes()); + } + }, + } + self.overflow |= overflow; + } +} + +#[derive(Clone, Copy)] +pub struct FunctionWriter { + pub layout: FunctionLayout, + pub output_size: usize, + pub seed_words: usize, + pub schema: &'static SeedSchema, + pub pack: fn(&SeedContext<'_>, &mut [u64]) -> TraceResult<()>, + pub pack_typed: fn(&SeedContext<'_>, &mut TypedSeed<'_>) -> TraceResult<()>, + pub write: fn(&[u64], RowOffsets, &mut [u64]) -> TraceResult<()>, +} + +pub struct GeneratedProgram { + pub fingerprint: [u8; 32], + pub complete: bool, + pub expected: fn() -> Toplevel, + pub functions: &'static [Option], +} + +pub struct BoundProgram<'a> { + generated: &'a GeneratedProgram, + bytecode: &'a Toplevel, +} + +pub struct BoundFunction<'a> { + index: usize, + writer: &'a FunctionWriter, + bytecode: &'a Toplevel, + input_runs: Vec, +} + +impl<'a> BoundFunction<'a> { + fn new( + index: usize, + writer: &'a FunctionWriter, + bytecode: &'a Toplevel, + ) -> Self { + let input_runs = writer.schema.input_runs(writer.layout.input_size); + Self { index, writer, bytecode, input_runs } + } +} + +fn same_block(a: &Block, b: &Block) -> bool { + let arms_equal = |a: &crate::FxIndexMap, + b: &crate::FxIndexMap| { + // Default-arm inverse columns follow case order; map equality ignores it. + a.len() == b.len() + && a.iter().zip(b).all(|((ka, a), (kb, b))| ka == kb && same_block(a, b)) + }; + let fallback_equal = + |a: &Option>, b: &Option>| match (a, b) { + (None, None) => true, + (Some(a), Some(b)) => same_block(a, b), + _ => false, + }; + a.ops == b.ops + && match (&a.ctrl, &b.ctrl) { + (Ctrl::Return(sa, va), Ctrl::Return(sb, vb)) + | (Ctrl::Yield(sa, va), Ctrl::Yield(sb, vb)) => sa == sb && va == vb, + (Ctrl::Match(da, aa, fa), Ctrl::Match(db, ab, fb)) => { + da == db && arms_equal(aa, ab) && fallback_equal(fa, fb) + }, + ( + Ctrl::MatchContinue(da, aa, fa, na, ca, la, ba), + Ctrl::MatchContinue(db, ab, fb, nb, cb, lb, bb), + ) => { + da == db + && na == nb + && ca == cb + && la == lb + && arms_equal(aa, ab) + && fallback_equal(fa, fb) + && same_block(ba, bb) + }, + _ => false, + } +} + +impl GeneratedProgram { + pub fn bind<'a>( + &'a self, + bytecode: &'a Toplevel, + ) -> Result, &'static str> { + let expected = (self.expected)(); + if self.fingerprint != contract::fingerprint(bytecode) + || !contract::validate_grouping(bytecode) + || expected.memory_sizes != bytecode.memory_sizes + || expected.functions.len() != bytecode.functions.len() + || self.functions.len() != bytecode.functions.len() + || expected.functions.iter().zip(&bytecode.functions).any(|(a, b)| { + !same_block(&a.body, &b.body) + || a.layout != b.layout + || a.entry != b.entry + || a.constrained != b.constrained + }) + { + return Err("generated trace library differs from the bytecode program"); + } + for (function, writer) in bytecode.functions.iter().zip(self.functions) { + if (self.complete && function.constrained && writer.is_none()) + || (!function.constrained && writer.is_some()) + || writer.as_ref().is_some_and(|writer| { + writer.layout != function.layout + || writer.schema.widths.len() != writer.seed_words + || !writer.schema.is_consistent() + }) + { + return Err( + "generated trace descriptors differ from the bytecode program", + ); + } + } + Ok(BoundProgram { generated: self, bytecode }) + } +} + +impl BoundProgram<'_> { + pub fn function(&self, index: usize) -> Option> { + Some(BoundFunction::new( + index, + self.generated.functions.get(index)?.as_ref()?, + self.bytecode, + )) + } +} + +impl BoundFunction<'_> { + pub fn seed_words(&self) -> usize { + self.writer.seed_words + } + + pub fn schema(&self) -> &'static SeedSchema { + self.writer.schema + } + + pub fn pack_row( + &self, + record: &QueryRecord, + io: &IOBuffer, + query: usize, + seed: &mut [u64], + ) -> TraceResult<()> { + if seed.len() != self.seed_words() { + return Err(error(self.index, None, "seed width mismatch")); + } + let (inputs, result) = record + .function_queries + .get(self.index) + .and_then(|queries| queries.get_index(query)) + .ok_or_else(|| error(self.index, None, "missing row query"))?; + if inputs.len() != self.writer.layout.input_size + || result.output.len() != self.writer.output_size + { + return Err(error(self.index, None, "row query arity mismatch")); + } + if result.multiplicity == G::ZERO { + return Err(error( + self.index, + None, + "zero-multiplicity function query has no trace row", + )); + } + seed.fill(0); + seed[0] = result.multiplicity.as_canonical_u64(); + for (dst, value) in seed[1..].iter_mut().zip(inputs) { + *dst = value.as_canonical_u64(); + } + let context = SeedContext { + inputs, + output: result.output, + multiplicity: result.multiplicity, + record, + io, + function: self.index, + }; + (self.writer.pack)(&context, seed).map_err(|mut error| { + error.query = Some(query); + error + }) + } + + /// Packs one row in the typed encoding and reports whether every narrowed + /// word fit. When one did not, the bytes are unusable and the row must be + /// packed full width. + pub fn pack_typed_row( + &self, + record: &QueryRecord, + io: &IOBuffer, + query: usize, + bytes: &mut [u8], + ) -> TraceResult { + let schema = self.writer.schema; + if bytes.len() != schema.bytes { + return Err(error(self.index, None, "typed seed width mismatch")); + } + let (inputs, result) = record + .function_queries + .get(self.index) + .and_then(|queries| queries.get_index(query)) + .ok_or_else(|| error(self.index, None, "missing row query"))?; + if inputs.len() != self.writer.layout.input_size + || result.output.len() != self.writer.output_size + || result.multiplicity == G::ZERO + { + return Err(error( + self.index, + None, + "row arity or multiplicity mismatch", + )); + } + bytes.fill(0); + bytes[..8] + .copy_from_slice(&result.multiplicity.as_canonical_u64().to_le_bytes()); + let mut seed = TypedSeed { bytes, overflow: 0 }; + for &run in &self.input_runs { + seed.run(run, inputs); + } + let context = SeedContext { + inputs, + output: result.output, + multiplicity: result.multiplicity, + record, + io, + function: self.index, + }; + (self.writer.pack_typed)(&context, &mut seed).map_err(|mut error| { + error.query = Some(query); + error + })?; + Ok(seed.overflow == 0) + } + + pub fn write_row( + &self, + seed: &[u64], + circuit: usize, + row: &mut [u64], + ) -> TraceResult<()> { + if seed.len() != self.seed_words() + || seed.first() == Some(&0) + || seed.iter().any(|&word| word >= G::ORDER_U64) + { + return Err(error( + self.index, + None, + "seed width, multiplicity, or canonical form mismatch", + )); + } + let circuit = self + .bytecode + .circuits + .get(circuit) + .ok_or_else(|| error(self.index, None, "missing circuit"))?; + let member = circuit + .members + .iter() + .position(|&member| member == self.index) + .ok_or_else(|| { + error(self.index, None, "function is not a member of this circuit") + })?; + if row.len() != circuit.layout.width() { + return Err(error(self.index, None, "row width mismatch")); + } + let selector_offset: usize = circuit.members[..member] + .iter() + .map(|&index| self.bytecode.functions[index].layout.selectors) + .sum(); + let offsets = RowOffsets { + selectors: circuit.layout.input_size + selector_offset, + auxiliaries: circuit.layout.input_size + circuit.layout.selectors, + }; + row.fill(0); + row[..self.writer.layout.input_size] + .copy_from_slice(&seed[1..1 + self.writer.layout.input_size]); + row[offsets.auxiliaries] = seed[0]; + (self.writer.write)(seed, offsets, row) + } +} + +/// Encoding is metadata for a homogeneous span, never inferred from byte +/// length. Multiplicities stay full width in both, including negative values. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SeedEncoding { + Canonical, + Typed, +} + +impl SeedEncoding { + pub fn stride(self, schema: &SeedSchema) -> usize { + match self { + Self::Canonical => 8 * schema.widths.len(), + Self::Typed => schema.bytes, + } + } + + pub fn encode( + self, + schema: &SeedSchema, + words: &[u64], + bytes: &mut [u8], + ) -> Result<(), &'static str> { + match self { + Self::Canonical => { + if words.len() != schema.widths.len() + || bytes.len() != self.stride(schema) + { + return Err("seed encoding width mismatch"); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + for (word, bytes) in words.iter().zip(bytes.as_chunks_mut::<8>().0) { + *bytes = word.to_le_bytes(); + } + Ok(()) + }, + Self::Typed => schema.encode(words, bytes), + } + } + + pub fn decode( + self, + schema: &SeedSchema, + bytes: &[u8], + words: &mut [u64], + ) -> Result<(), &'static str> { + match self { + Self::Canonical => { + if words.len() != schema.widths.len() + || bytes.len() != self.stride(schema) + { + return Err("seed encoding width mismatch"); + } + for (word, bytes) in words.iter_mut().zip(bytes.as_chunks::<8>().0) { + *word = u64::from_le_bytes(*bytes); + } + if words.iter().any(|&word| word >= G::ORDER_U64) { + return Err("seed words must be canonical"); + } + Ok(()) + }, + Self::Typed => schema.decode(bytes, words), + } + } +} + +pub fn u32_word(bytes: [G; 4]) -> u64 { + bytes + .iter() + .enumerate() + .fold(0, |word, (i, byte)| word | (byte.as_canonical_u64() << (8 * i))) +} + +pub fn u32_add(words: &[u64]) -> [G; 5] { + let sum: u128 = words.iter().map(|&word| u128::from(word)).sum(); + let bytes = u32::try_from(sum & 0xffff_ffff) + .expect("32 bits") + .to_le_bytes() + .map(G::from_u8); + [ + bytes[0], + bytes[1], + bytes[2], + bytes[3], + G::from_u64(u64::try_from(sum >> 32).expect("carry fits")), + ] +} + +/// The comparison and its six u16 limbs ordered as `a`, `a - b`, `b`, low +/// limb first: the host witness's scalar range-check queries. +pub fn u32_less_than(a: G, b: G) -> (G, [G; 6]) { + let a = u32::try_from(a.as_canonical_u64()).expect("u32 operand"); + let b = u32::try_from(b.as_canonical_u64()).expect("u32 operand"); + let c = a.wrapping_sub(b); + let mut limbs = [G::ZERO; 6]; + for (dst, word) in limbs.as_chunks_mut::<2>().0.iter_mut().zip([a, c, b]) { + *dst = [G::from_u32(word & 0xffff), G::from_u32(word >> 16)]; + } + (G::from_bool(a < b), limbs) +} + +#[cfg(test)] +pub(crate) mod tests; diff --git a/crates/aiur/src/trace_codegen/contract.rs b/crates/aiur/src/trace_codegen/contract.rs new file mode 100644 index 000000000..ff0fd1181 --- /dev/null +++ b/crates/aiur/src/trace_codegen/contract.rs @@ -0,0 +1,225 @@ +//! Versioned bytecode identity shared with `Aiur.TraceContract`. + +use super::*; +use crate::bytecode::{Ctrl, Op}; + +struct Encoder(blake3::Hasher); +impl Encoder { + fn byte(&mut self, value: u8) { + self.0.update(&[value]); + } + fn word(&mut self, value: u64) { + self.0.update(&value.to_le_bytes()); + } + fn index(&mut self, value: usize) { + self.word(value.try_into().expect("64-bit index")); + } + fn indices(&mut self, values: &[usize]) { + self.index(values.len()); + for &value in values { + self.index(value); + } + } + fn string(&mut self, value: &str) { + self.index(value.len()); + self.0.update(value.as_bytes()); + } + fn unary(&mut self, tag: u8, a: usize) { + self.byte(tag); + self.index(a); + } + fn binary(&mut self, tag: u8, a: usize, b: usize) { + self.unary(tag, a); + self.index(b); + } + fn operation(&mut self, op: &Op) { + match op { + Op::Const(g) => { + self.byte(0); + self.word(g.as_canonical_u64()); + }, + Op::Add(a, b) => self.binary(1, *a, *b), + Op::Sub(a, b) => self.binary(2, *a, *b), + Op::Mul(a, b) => self.binary(3, *a, *b), + Op::EqZero(a) => self.unary(4, *a), + Op::Call(f, args, n, u) => { + self.unary(5, *f); + self.indices(args); + self.index(*n); + self.byte(u8::from(*u)); + }, + Op::Store(xs) => { + self.byte(6); + self.indices(xs); + }, + Op::Load(n, p) => self.binary(7, *n, *p), + Op::AssertEq(a, b, msg) => { + self.byte(8); + self.indices(a); + self.indices(b); + self.byte(u8::from(msg.is_some())); + if let Some(msg) = msg { + self.string(msg); + } + }, + Op::IOGetInfo(c, key) => { + self.unary(9, *c); + self.indices(key); + }, + Op::IOSetInfo(c, key, i, n) => { + self.unary(10, *c); + self.indices(key); + self.index(*i); + self.index(*n); + }, + Op::IORead(c, i, n) => { + self.binary(11, *c, *i); + self.index(*n); + }, + Op::IOWrite(c, xs) => { + self.unary(12, *c); + self.indices(xs); + }, + Op::U8BitDecomposition(a) => self.unary(13, *a), + Op::U8ShiftLeft(a) => self.unary(14, *a), + Op::U8ShiftRight(a) => self.unary(15, *a), + Op::U8Xor(a, b) => self.binary(16, *a, *b), + Op::U8Add(a, b) => self.binary(17, *a, *b), + Op::U8Mul(a, b) => self.binary(18, *a, *b), + Op::U8Sub(a, b) => self.binary(19, *a, *b), + Op::U8And(a, b) => self.binary(20, *a, *b), + Op::U8Or(a, b) => self.binary(21, *a, *b), + Op::U8LessThan(a, b) => self.binary(22, *a, *b), + Op::U32LessThan(a, b) => self.binary(23, *a, *b), + Op::U8XorSplit7(a, b) => self.binary(24, *a, *b), + Op::U8XorSplit4(a, b) => self.binary(25, *a, *b), + Op::Debug(msg, args) => { + self.byte(26); + self.string(msg); + self.byte(u8::from(args.is_some())); + if let Some(args) = args { + self.indices(args); + } + }, + Op::U8RangeCheck(a, b) => self.binary(27, *a, *b), + Op::UnconstrainedBigUintDivMod(a, b) => self.binary(28, *a, *b), + Op::UnconstrainedGToBytes(a) => self.unary(29, *a), + Op::UnconstrainedGInverse(a) => self.unary(30, *a), + Op::UnconstrainedU32Add(a, b) => { + self.byte(31); + self.indices(a); + self.indices(b); + }, + Op::UnconstrainedU32Add3(a, b, c) => { + self.byte(32); + self.indices(a); + self.indices(b); + self.indices(c); + }, + Op::U32ToField(a) => { + self.byte(33); + self.indices(a); + }, + } + } + fn arms( + &mut self, + arms: &crate::FxIndexMap, + fallback: &Option>, + ) { + self.index(arms.len()); + for (value, block) in arms { + self.word(value.as_canonical_u64()); + self.block(block); + } + self.byte(u8::from(fallback.is_some())); + if let Some(block) = fallback { + self.block(block); + } + } + fn block(&mut self, block: &Block) { + self.index(block.ops.len()); + for op in &block.ops { + self.operation(op); + } + match &block.ctrl { + Ctrl::Match(d, arms, fallback) => { + self.unary(0, *d); + self.arms(arms, fallback); + }, + Ctrl::Return(s, xs) => { + self.unary(1, *s); + self.indices(xs); + }, + Ctrl::Yield(s, xs) => { + self.unary(2, *s); + self.indices(xs); + }, + Ctrl::MatchContinue(d, arms, fallback, n, aux, lookup, continuation) => { + self.unary(3, *d); + self.arms(arms, fallback); + self.index(*n); + self.index(*aux); + self.index(*lookup); + self.block(continuation); + }, + } + } + fn layout(&mut self, l: &FunctionLayout) { + self.index(l.input_size); + self.index(l.selectors); + self.index(l.auxiliaries); + self.index(l.lookups); + } +} + +/// Grouping is validated separately so one writer can populate singleton or +/// merged circuits without changing its function-library identity. +pub fn fingerprint(top: &Toplevel) -> [u8; 32] { + let mut e = Encoder(blake3::Hasher::new()); + e.0.update(b"aiur-trace-library-v1/seed-v2/writer-v2\0"); + e.index(top.functions.len()); + for function in &top.functions { + e.layout(&function.layout); + e.byte(u8::from(function.entry)); + e.byte(u8::from(function.constrained)); + e.block(&function.body); + } + e.indices(&top.memory_sizes); + *e.0.finalize().as_bytes() +} + +pub(super) fn validate_grouping(top: &Toplevel) -> bool { + let mut seen = vec![false; top.functions.len()]; + for circuit in &top.circuits { + let mut layout = FunctionLayout { + input_size: 0, + selectors: 0, + auxiliaries: 0, + lookups: 0, + }; + if circuit.members.is_empty() { + return false; + } + for &member in &circuit.members { + let Some(function) = top.functions.get(member) else { + return false; + }; + if !function.constrained || std::mem::replace(&mut seen[member], true) { + return false; + } + let l = function.layout; + layout.input_size = layout.input_size.max(l.input_size); + let Some(selectors) = layout.selectors.checked_add(l.selectors) else { + return false; + }; + layout.selectors = selectors; + layout.auxiliaries = layout.auxiliaries.max(l.auxiliaries); + layout.lookups = layout.lookups.max(l.lookups); + } + if layout != circuit.layout { + return false; + } + } + seen.iter().zip(&top.functions).all(|(&seen, f)| seen == f.constrained) +} diff --git a/crates/aiur/src/trace_codegen/cuda.rs b/crates/aiur/src/trace_codegen/cuda.rs new file mode 100644 index 000000000..d4618d37e --- /dev/null +++ b/crates/aiur/src/trace_codegen/cuda.rs @@ -0,0 +1,1030 @@ +//! CUDA rows from owned, immutable, encoded seeds. + +use std::sync::{ + Arc, Mutex, OnceLock, + atomic::{AtomicUsize, Ordering}, +}; + +use rayon::prelude::*; + +use multi_stark::{ + cuda::DeviceTraceView, + lookup::LookupValues, + witness::{TraceGenerator, TraceSource}, +}; + +use super::*; +use crate::trace::QueryPosition; + +const MAX_ROWS: usize = 65537; +const MAX_SEED_BYTES: usize = 16 * 1024 * 1024 - 8; + +type Kernel = unsafe extern "C" fn( + i32, + *const u8, + u32, + usize, + usize, + usize, + usize, + usize, + *mut u64, +) -> i32; + +pub struct CudaLibrary { + fingerprint: [u8; 32], + contract: unsafe extern "C" fn() -> *const u8, + schema: unsafe extern "C" fn() -> *const u8, + functions: &'static [Option], + seed_words: &'static [usize], + typed_bytes: &'static [usize], +} + +/// The seed layouts the compiled unit was generated with, as the unit hashes +/// them: the same encoding `Aiur.TraceCuda` emits into `aiur_trace_*_schema`, +/// recomputed here from the Rust writers so the kernels' typed loads and the +/// packers' typed stores are proven to agree at bind, not assumed from a +/// shared generation run. +pub fn schema_contract(functions: &[Option]) -> [u8; 32] { + let mut hasher = blake3::Hasher::new(); + hasher.update(b"aiur-trace-schema-v1\0"); + for (index, writer) in functions.iter().enumerate() { + let Some(writer) = writer else { continue }; + for word in [index, writer.seed_words, writer.schema.bytes] { + hasher.update(&(word as u64).to_le_bytes()); + } + for &width in writer.schema.widths { + hasher.update(&[ + u8::try_from(width.bytes()).expect("seed widths fit a byte") + ]); + } + for &offset in writer.schema.offsets { + hasher.update(&(offset as u64).to_le_bytes()); + } + } + *hasher.finalize().as_bytes() +} + +impl CudaLibrary { + /// # Safety + /// The contract and schema functions must return 32 readable immutable + /// bytes. Every kernel must implement the generated seed/writer ABI for its + /// function index, validate output dimensions, and finish all accesses + /// before returning. + pub const unsafe fn new( + fingerprint: [u8; 32], + contract: unsafe extern "C" fn() -> *const u8, + schema: unsafe extern "C" fn() -> *const u8, + functions: &'static [Option], + seed_words: &'static [usize], + typed_bytes: &'static [usize], + ) -> Self { + Self { fingerprint, contract, schema, functions, seed_words, typed_bytes } + } + + pub fn bind<'a>( + &'static self, + generated: &'static GeneratedProgram, + bytecode: &'a Toplevel, + ) -> Result, &'static str> { + generated.bind(bytecode)?; + let compiled = unsafe { std::slice::from_raw_parts((self.contract)(), 32) }; + if generated.fingerprint != self.fingerprint + || compiled != self.fingerprint + || self.functions.len() != generated.functions.len() + || self.seed_words.len() != self.functions.len() + || self.typed_bytes.len() != self.functions.len() + { + return Err("CUDA unit differs from the generated seed/writer contract"); + } + let schemas = unsafe { std::slice::from_raw_parts((self.schema)(), 32) }; + if schemas != schema_contract(generated.functions) { + return Err("CUDA unit was compiled for different seed layouts"); + } + for (((kernel, writer), &words), &typed) in self + .functions + .iter() + .zip(generated.functions) + .zip(self.seed_words) + .zip(self.typed_bytes) + { + if kernel.is_some() + && writer.as_ref().is_none_or(|writer| { + writer.seed_words != words || writer.schema.bytes != typed + }) + { + return Err("CUDA kernel has no matching seed writer"); + } + } + Ok(BoundCudaProgram { library: self, generated, bytecode }) + } + + pub(crate) fn register( + &'static self, + generated: &'static GeneratedProgram, + bytecode: Arc, + ) -> Result { + self.bind(generated, &bytecode)?; + Ok(RegisteredCudaProgram { library: self, generated, bytecode }) + } +} + +/// A validated library and its immutable bytecode travel together across GPUs. +pub(crate) struct RegisteredCudaProgram { + library: &'static CudaLibrary, + generated: &'static GeneratedProgram, + bytecode: Arc, +} + +impl RegisteredCudaProgram { + pub(crate) fn bound(&self) -> BoundCudaProgram<'_> { + BoundCudaProgram { + library: self.library, + generated: self.generated, + bytecode: &self.bytecode, + } + } +} + +pub struct BoundCudaProgram<'a> { + library: &'static CudaLibrary, + generated: &'static GeneratedProgram, + bytecode: &'a Toplevel, +} + +impl BoundCudaProgram<'_> { + pub fn supports(&self, circuit: usize) -> bool { + self.bytecode.circuits.get(circuit).is_some_and(|c| { + c.members.iter().all(|&f| self.library.functions[f].is_some()) + }) + } + + /// The finalized record and I/O stay borrowed until packing finishes. The + /// returned source owns its seeds; dropping or regenerating another batch + /// cannot change these rows. + /// + /// With `retain_device_seeds`, the first device tile the source serves + /// uploads every seed span once and later tiles, such as the lookup pass's + /// regeneration of a committed trace, run from that copy; the backend + /// frees it after the lookup or under memory pressure. + pub fn prepare( + &self, + circuit: usize, + record: &QueryRecord, + io: &IOBuffer, + slots: &[usize], + start: QueryPosition, + end: QueryPosition, + row_count: usize, + retain_device_seeds: bool, + ) -> TraceResult<(TraceSource, LookupValues)> { + let (source, lookups) = self.prepare_trace( + circuit, + record, + io, + slots, + start, + end, + row_count, + retain_device_seeds, + )?; + Ok((TraceSource::Generated(Arc::new(source)), lookups)) + } + + /// [`Self::prepare`] before the source is erased behind the trait, so the + /// packed seeds can be inspected. + pub(crate) fn prepare_trace( + &self, + circuit: usize, + record: &QueryRecord, + io: &IOBuffer, + slots: &[usize], + start: QueryPosition, + end: QueryPosition, + row_count: usize, + retain_device_seeds: bool, + ) -> TraceResult<(CudaTrace, LookupValues)> { + let _span = + tracing::info_span!("aiur/codegen_seeds", circuit, rows = row_count) + .entered(); + if !self.supports(circuit) || row_count == 0 { + return Err(error( + 0, + None, + "missing CUDA circuit coverage or empty span", + )); + } + let c = &self.bytecode.circuits[circuit]; + let mut spans: Vec = Vec::new(); + let mut count = 0usize; + let mut selectors = c.layout.input_size; + for (member, &function) in c.members.iter().enumerate() { + let writer = self.generated.functions[function].as_ref().unwrap(); + let offsets = RowOffsets { + selectors, + auxiliaries: c.layout.input_size + c.layout.selectors, + }; + selectors += writer.layout.selectors; + if member < start.0 || member > end.0 { + continue; + } + let bound = BoundFunction::new(function, writer, self.bytecode); + let queries = record + .function_queries + .get(function) + .ok_or_else(|| error(function, None, "record has no function table"))?; + let lo = if member == start.0 { start.1 } else { 0 }; + let hi = if member == end.0 { end.1 } else { queries.len() }; + if lo > hi || hi > queries.len() { + return Err(error(function, None, "invalid query span")); + } + let schema = writer.schema; + if SeedEncoding::Canonical.stride(schema) > MAX_SEED_BYTES { + return Err(error(function, None, "seed exceeds the upload limit")); + } + let live: Vec = { + let _filter = + tracing::info_span!("aiur/codegen_filter", function).entered(); + (lo..hi) + .filter(|&query| { + queries.get_index(query).unwrap().1.multiplicity != G::ZERO + }) + .collect() + }; + if live.is_empty() { + continue; + } + // Chunks pack in parallel. A chunk is typed while every narrowed word + // fits and turns full width at its first wide row, re-encoding its + // earlier rows from their typed bytes. A member run then takes one + // codec: if any chunk turned, the others are widened the same way, so + // no row is ever packed twice and no span mixes encodings. + let typed_first = !schema.is_canonical(); + let mut chunks = { + let _pack = + tracing::info_span!("aiur/codegen_pack", function, rows = live.len()) + .entered(); + live + .par_chunks(CHUNK_ROWS) + .map(|rows| pack_chunk(&bound, record, io, rows, typed_first)) + .collect::>>()? + }; + if typed_first + && chunks.iter().any(|chunk| chunk.encoding == SeedEncoding::Canonical) + { + let _widen = + tracing::info_span!("aiur/codegen_widen", function).entered(); + chunks.par_iter_mut().for_each(|chunk| chunk.widen(schema)); + } + let _concat = + tracing::info_span!("aiur/codegen_concat", function).entered(); + // Every chunk of the run now shares one encoding, so a span's final + // size is known when it opens: the rest of the run, within the tile and + // staging limits. + let mut run_remaining: usize = + chunks.iter().map(|chunk| chunk.rows).sum(); + for chunk in chunks { + let stride = chunk.encoding.stride(schema); + let mut offset = 0; + let mut remaining = chunk.rows; + while remaining > 0 { + let open = spans.last().is_some_and(|s| { + s.function == function + && s.encoding == chunk.encoding + && s.rows < MAX_ROWS + && s.bytes.len() + stride <= MAX_SEED_BYTES + }); + if !open { + spans.push(SeedSpan { + first: count, + rows: 0, + function, + writer, + kernel: self.library.functions[function].unwrap(), + offsets, + encoding: chunk.encoding, + stride, + bytes: Vec::with_capacity( + run_remaining.min(MAX_ROWS).min(MAX_SEED_BYTES / stride) + * stride, + ), + }); + } + let span = spans.last_mut().unwrap(); + let take = remaining + .min(MAX_ROWS - span.rows) + .min((MAX_SEED_BYTES - span.bytes.len()) / stride); + span + .bytes + .extend_from_slice(&chunk.bytes[offset..offset + take * stride]); + span.rows += take; + count += take; + offset += take * stride; + remaining -= take; + run_remaining -= take; + } + } + } + if count != row_count { + return Err(error(0, None, "packed row count differs from query span")); + } + let height = count + .checked_next_power_of_two() + .ok_or_else(|| error(0, None, "trace height overflow"))?; + let source = CudaTrace::new( + spans, + height, + count, + c.layout.width(), + retain_device_seeds, + ); + tracing::debug!( + circuit, + rows = count, + width = source.width, + seed_bytes = + source.spans.iter().map(|span| span.bytes.len()).sum::(), + seed_spans = source.spans.len(), + "prepared generated CUDA trace" + ); + Ok((source, LookupValues::shape_only(height, slots))) + } +} + +struct SeedSpan { + first: usize, + rows: usize, + function: usize, + writer: &'static FunctionWriter, + kernel: Kernel, + offsets: RowOffsets, + encoding: SeedEncoding, + stride: usize, + bytes: Vec, +} + +/// Rows packed together by one worker; see `prepare`. +const CHUNK_ROWS: usize = 4096; + +struct PackedChunk { + rows: usize, + encoding: SeedEncoding, + bytes: Vec, +} + +impl PackedChunk { + /// Typed bytes decode exactly, so widening never packs a row again. + fn widen(&mut self, schema: &SeedSchema) { + if self.encoding == SeedEncoding::Typed { + self.bytes = widen_bytes(&self.bytes, schema); + self.encoding = SeedEncoding::Canonical; + } + } +} + +fn widen_bytes(typed: &[u8], schema: &SeedSchema) -> Vec { + let typed_stride = schema.bytes; + let canonical_stride = SeedEncoding::Canonical.stride(schema); + let rows = typed.len() / typed_stride; + let mut words = vec![0; schema.widths.len()]; + let mut canonical = vec![0; rows * canonical_stride]; + for row in 0..rows { + schema + .decode(&typed[row * typed_stride..(row + 1) * typed_stride], &mut words) + .expect("typed rows were validated"); + SeedEncoding::Canonical + .encode( + schema, + &words, + &mut canonical[row * canonical_stride..(row + 1) * canonical_stride], + ) + .expect("decoded words are canonical"); + } + canonical +} + +fn pack_chunk( + bound: &BoundFunction<'_>, + record: &QueryRecord, + io: &IOBuffer, + rows: &[usize], + typed_first: bool, +) -> TraceResult { + let schema = bound.schema(); + let typed_stride = schema.bytes; + let canonical_stride = SeedEncoding::Canonical.stride(schema); + let mut encoding = + if typed_first { SeedEncoding::Typed } else { SeedEncoding::Canonical }; + let mut bytes = Vec::with_capacity(rows.len() * encoding.stride(schema)); + let mut seed = vec![0; bound.seed_words()]; + for &query in rows { + if encoding == SeedEncoding::Typed { + let offset = bytes.len(); + bytes.resize(offset + typed_stride, 0); + if bound.pack_typed_row(record, io, query, &mut bytes[offset..])? { + continue; + } + bytes.truncate(offset); + bytes = widen_bytes(&bytes, schema); + encoding = SeedEncoding::Canonical; + } + bound.pack_row(record, io, query, &mut seed)?; + let offset = bytes.len(); + bytes.resize(offset + canonical_stride, 0); + SeedEncoding::Canonical + .encode(schema, &seed, &mut bytes[offset..]) + .map_err(|e| error(bound.index, None, e))?; + } + Ok(PackedChunk { rows: rows.len(), encoding, bytes }) +} + +pub struct CudaTrace { + spans: Vec, + height: usize, + real: usize, + width: usize, + /// Byte offset of each span in the device copy of all seeds, then the + /// total, so a span's device seeds are `base + offsets[span]`. + offsets: Vec, + retain_device_seeds: bool, + device_seeds: Mutex>, +} + +/// One device's copy of every seed span of a source. +struct DeviceSeeds { + device: i32, + base: *mut u8, +} + +// SAFETY: the pointer is a device allocation the CUDA runtime hands out +// and frees; no host thread dereferences it. +unsafe impl Send for DeviceSeeds {} + +/// Device seed bytes held per device across the process, against +/// [`seed_cache_limit`]. +static SEED_CACHE_BYTES: [AtomicUsize; 64] = + [const { AtomicUsize::new(0) }; 64]; + +/// The most seed bytes kept resident per device, `AIUR_GPU_SEED_CACHE_BYTES` +/// or 16 GiB. The backend releases caches before it spills any LDE, so the +/// limit bounds the footprint rather than protecting admission. +fn seed_cache_limit() -> usize { + static LIMIT: OnceLock = OnceLock::new(); + *LIMIT.get_or_init(|| { + std::env::var("AIUR_GPU_SEED_CACHE_BYTES") + .ok() + .and_then(|value| value.parse().ok()) + .unwrap_or(16 << 30) + }) +} + +/// Seed bytes currently resident on `device` across every source. +#[cfg(test)] +pub(crate) fn seed_cache_bytes(device: i32) -> usize { + SEED_CACHE_BYTES[usize::try_from(device).unwrap()].load(Ordering::Acquire) +} + +/// Seed cache uploads so far in the process. +#[cfg(test)] +pub(crate) static SEED_CACHE_UPLOADS: AtomicUsize = AtomicUsize::new(0); + +impl CudaTrace { + fn new( + spans: Vec, + height: usize, + real: usize, + width: usize, + retain_device_seeds: bool, + ) -> Self { + let mut offsets = Vec::with_capacity(spans.len() + 1); + let mut total = 0; + for span in &spans { + offsets.push(total); + total += span.bytes.len(); + } + offsets.push(total); + Self { + spans, + height, + real, + width, + offsets, + retain_device_seeds, + device_seeds: Mutex::new(Vec::new()), + } + } + + fn span_index(&self, row: usize) -> usize { + self.spans.partition_point(|s| s.first <= row).saturating_sub(1) + } + + fn span(&self, row: usize) -> &SeedSpan { + &self.spans[self.span_index(row)] + } + + fn seed_bytes(&self) -> usize { + *self.offsets.last().unwrap_or(&0) + } + + /// The device copy of all seed spans on `device`, uploaded on first use + /// within the cache limit; `None` serves the tile from the host instead. + /// The copy is one allocation, so the spans are uploaded together and + /// released together. + fn resident_seeds(&self, device: i32) -> Option<*const u8> { + if !self.retain_device_seeds || self.spans.is_empty() { + return None; + } + let mut cached = self.device_seeds.lock().unwrap(); + if let Some(seeds) = cached.iter_mut().find(|seeds| seeds.device == device) + { + return Some(seeds.base); + } + let counter = SEED_CACHE_BYTES.get(usize::try_from(device).ok()?)?; + let bytes = self.seed_bytes(); + if counter + .fetch_update(Ordering::AcqRel, Ordering::Acquire, |held| { + (held + bytes <= seed_cache_limit()).then_some(held + bytes) + }) + .is_err() + { + tracing::debug!(device, bytes, "seed cache limit reached"); + return None; + } + let pointers: Vec<*const u8> = + self.spans.iter().map(|span| span.bytes.as_ptr()).collect(); + let lengths: Vec = + self.spans.iter().map(|span| span.bytes.len()).collect(); + let mut base: *mut u8 = std::ptr::null_mut(); + let status = unsafe { + aiur_trace_seed_cache_upload( + device, + pointers.as_ptr(), + lengths.as_ptr(), + pointers.len(), + bytes, + &mut base, + ) + }; + if status != 0 { + counter.fetch_sub(bytes, Ordering::AcqRel); + tracing::debug!(device, bytes, status, "seed cache upload failed"); + return None; + } + tracing::debug!( + device, + bytes, + spans = pointers.len(), + "seed cache uploaded" + ); + #[cfg(test)] + SEED_CACHE_UPLOADS.fetch_add(1, Ordering::AcqRel); + cached.push(DeviceSeeds { device, base }); + Some(base) + } + + fn free_device_seeds(&self, keep: impl Fn(i32) -> bool) { + let mut cached = self.device_seeds.lock().unwrap(); + cached.retain(|seeds| { + if keep(seeds.device) { + return true; + } + let status = + unsafe { aiur_trace_seed_cache_free(seeds.device, seeds.base) }; + if status != 0 { + tracing::warn!( + device = seeds.device, + status, + "seed cache release failed" + ); + } + if let Some(counter) = + usize::try_from(seeds.device).ok().and_then(|d| SEED_CACHE_BYTES.get(d)) + { + counter.fetch_sub(self.seed_bytes(), Ordering::AcqRel); + } + false + }); + } +} + +impl Drop for CudaTrace { + fn drop(&mut self) { + self.free_device_seeds(|_| false); + } +} + +#[cfg(test)] +impl CudaTrace { + /// Host memory the packed seeds occupy, reservations included. + pub(crate) fn host_bytes(&self) -> usize { + self.spans.capacity() * size_of::() + + self.spans.iter().map(|s| s.bytes.capacity()).sum::() + } +} + +impl TraceGenerator for CudaTrace { + fn height(&self) -> usize { + self.height + } + fn width(&self) -> usize { + self.width + } + fn write_rows(&self, first: usize, output: &mut [G]) { + assert_eq!(output.len() % self.width, 0); + let mut seed = Vec::new(); + let mut canonical = vec![0; self.width]; + let mut index = first % self.height; + for row in output.chunks_exact_mut(self.width) { + row.fill(G::ZERO); + if index < self.real { + let span = self.span(index); + seed.resize(span.writer.seed_words, 0); + let offset = (index - span.first) * span.stride; + span + .encoding + .decode( + span.writer.schema, + &span.bytes[offset..offset + span.stride], + &mut seed, + ) + .expect("validated seed"); + canonical.fill(0); + canonical[..span.writer.layout.input_size] + .copy_from_slice(&seed[1..1 + span.writer.layout.input_size]); + canonical[span.offsets.auxiliaries] = seed[0]; + (span.writer.write)(&seed, span.offsets, &mut canonical) + .expect("valid generated row"); + for (dst, &word) in row.iter_mut().zip(&canonical) { + *dst = G::from_u64(word); + } + } + index = (index + 1) % self.height; + } + } + fn write_device_rows(&self, view: DeviceTraceView<'_>) -> Result<(), String> { + if view.width() != self.width { + return Err("CUDA trace width mismatch".into()); + } + self.write_tile( + view.device_id(), + view.first_row(), + view.rows(), + view.as_mut_ptr(), + ) + } + fn release_device(&self, device_id: i32) { + self.free_device_seeds(|device| device != device_id); + } +} + +impl CudaTrace { + /// Rows `[first_row, first_row + tile_rows)` of the padded trace, wrapping at + /// its height, written to `output` on `device`: the writer behind + /// [`TraceGenerator::write_device_rows`], reachable without a view. + fn write_tile( + &self, + device: i32, + first_row: usize, + tile_rows: usize, + output: *mut u64, + ) -> Result<(), String> { + let _span = tracing::info_span!( + "aiur/codegen_device_rows", + device, + first = first_row, + rows = tile_rows, + width = self.width + ) + .entered(); + let resident = self.resident_seeds(device); + let mut done = 0; + let mut first = first_row % self.height; + while done < tile_rows { + let index = self.span_index(first.min(self.real - 1)); + let span = &self.spans[index]; + let remaining = (tile_rows - done).min(self.height - first).min(MAX_ROWS); + let (rows, real, seeds) = if first >= self.real { + (remaining, 0, std::ptr::null()) + } else { + let rows = remaining.min(span.first + span.rows - first); + let offset = (first - span.first) * span.stride; + let seeds = match resident { + Some(base) => unsafe { base.add(self.offsets[index] + offset) }, + None => span.bytes[offset..].as_ptr(), + }; + (rows, rows, seeds) + }; + let encoding = match span.encoding { + SeedEncoding::Canonical => 0, + SeedEncoding::Typed => 1, + }; + let status = unsafe { + (span.kernel)( + device, + seeds, + encoding, + real, + rows, + self.width, + span.offsets.selectors, + span.offsets.auxiliaries, + output.add(done * self.width), + ) + }; + if status != 0 { + return Err(format!( + "generated CUDA function {}, row {first}: status {status}", + span.function + )); + } + done += rows; + first = (first + rows) % self.height; + } + Ok(()) + } + + /// The tile [`Self::write_tile`] writes on `device`, read back as raw + /// words. + #[cfg(test)] + pub(crate) fn download_tile( + &self, + device: i32, + first_row: usize, + tile_rows: usize, + ) -> Vec { + let words = tile_rows * self.width; + let mut tile = std::ptr::null_mut(); + let status = unsafe { aiur_trace_tile_alloc(device, words, &mut tile) }; + assert_eq!(status, 0, "device tile allocation"); + let written = self.write_tile(device, first_row, tile_rows, tile); + let mut host = vec![0u64; words]; + let status = unsafe { + aiur_trace_tile_download(device, tile, words, host.as_mut_ptr()) + }; + written.expect("device writer"); + assert_eq!(status, 0, "device tile download"); + host + } +} + +unsafe extern "C" { + fn aiur_trace_seed_cache_upload( + device: i32, + spans: *const *const u8, + lengths: *const usize, + count: usize, + total: usize, + cached: *mut *mut u8, + ) -> i32; + fn aiur_trace_seed_cache_free(device: i32, cached: *mut u8) -> i32; + #[cfg(test)] + fn aiur_trace_tile_alloc( + device: i32, + words: usize, + tile: *mut *mut u64, + ) -> i32; + #[cfg(test)] + fn aiur_trace_tile_download( + device: i32, + tile: *mut u64, + words: usize, + host: *mut u64, + ) -> i32; + fn aiur_trace_memory( + device: i32, + seeds: *const u8, + values: usize, + real: usize, + rows: usize, + output: *mut u64, + ) -> i32; +} + +/// One memory table range as `[multiplicity, 1, pointer, values]` rows, built +/// on the device from `[multiplicity, pointer, values]` seeds. The seeds are +/// canonical words copied out of the record, so no packer runs; every table +/// row is real, zero multiplicities included, exactly as the CPU builder +/// emits them. +pub struct MemoryTrace { + values: usize, + spans: Vec, + height: usize, + real: usize, +} + +struct MemorySpan { + first: usize, + rows: usize, + bytes: Vec, +} + +impl MemoryTrace { + fn stride(&self) -> usize { + 8 * (self.values + 2) + } + + fn span(&self, row: usize) -> &MemorySpan { + let index = + self.spans.partition_point(|s| s.first <= row).saturating_sub(1); + &self.spans[index] + } +} + +/// The width-`size` table's rows at table indices `range`, row `i` carrying +/// pointer `record.pointer_base + range.start + i`. An empty range is the CPU +/// builder's case: it yields an empty trace that the prover deactivates. +pub fn prepare_memory( + record: &QueryRecord, + size: usize, + slots: &[usize], + range: std::ops::Range, +) -> TraceResult<(TraceSource, LookupValues)> { + let (source, lookups) = prepare_memory_trace(record, size, slots, range)?; + Ok((TraceSource::Generated(Arc::new(source)), lookups)) +} + +/// [`prepare_memory`] before the source is erased behind the trait. +pub(crate) fn prepare_memory_trace( + record: &QueryRecord, + size: usize, + slots: &[usize], + range: std::ops::Range, +) -> TraceResult<(MemoryTrace, LookupValues)> { + let _span = + tracing::info_span!("aiur/codegen_memory_seeds", size, rows = range.len()) + .entered(); + let queries = record.memory_queries.get(&size).ok_or_else(|| { + error(0, None, "record has no memory table of this width") + })?; + if range.is_empty() || range.end > queries.len() { + return Err(error(0, None, "invalid memory table range")); + } + let stride = 8 * (size + 2); + if stride > MAX_SEED_BYTES { + return Err(error(0, None, "memory seed exceeds the upload limit")); + } + let per_span = MAX_ROWS.min(MAX_SEED_BYTES / stride); + let count = range.len(); + let spans: Vec = (0..count) + .step_by(per_span) + .collect::>() + .into_par_iter() + .map(|first| { + let rows = per_span.min(count - first); + let mut bytes = vec![0; rows * stride]; + for (i, seed) in bytes.chunks_exact_mut(stride).enumerate() { + let index = range.start + first + i; + let (values, result) = + queries.get_index(index).expect("table index in range"); + let pointer = G::from_usize(record.pointer_base + index); + seed[..8].copy_from_slice( + &result.multiplicity.as_canonical_u64().to_le_bytes(), + ); + seed[8..16].copy_from_slice(&pointer.as_canonical_u64().to_le_bytes()); + let (words, _) = seed[16..].as_chunks_mut::<8>(); + for (dst, value) in words.iter_mut().zip(values) { + *dst = value.as_canonical_u64().to_le_bytes(); + } + } + MemorySpan { first, rows, bytes } + }) + .collect(); + let height = count + .checked_next_power_of_two() + .ok_or_else(|| error(0, None, "trace height overflow"))?; + tracing::debug!( + size, + rows = count, + seed_bytes = count * stride, + seed_spans = spans.len(), + "prepared generated memory trace" + ); + Ok(( + MemoryTrace { values: size, spans, height, real: count }, + LookupValues::shape_only(height, slots), + )) +} + +impl TraceGenerator for MemoryTrace { + fn height(&self) -> usize { + self.height + } + fn width(&self) -> usize { + self.values + 3 + } + fn write_rows(&self, first: usize, output: &mut [G]) { + let width = self.width(); + assert_eq!(output.len() % width, 0); + let stride = self.stride(); + let mut index = first % self.height; + for row in output.chunks_exact_mut(width) { + row.fill(G::ZERO); + if index < self.real { + let span = self.span(index); + let offset = (index - span.first) * stride; + let seed = &span.bytes[offset..offset + stride]; + let word = |i: usize| { + G::from_u64(u64::from_le_bytes( + seed[8 * i..8 * i + 8].try_into().expect("eight bytes"), + )) + }; + row[0] = word(0); + row[1] = G::ONE; + row[2] = word(1); + for (i, cell) in row[3..].iter_mut().enumerate() { + *cell = word(2 + i); + } + } + index = (index + 1) % self.height; + } + } + fn write_device_rows(&self, view: DeviceTraceView<'_>) -> Result<(), String> { + if view.width() != self.width() { + return Err("memory trace width mismatch".into()); + } + self.write_tile( + view.device_id(), + view.first_row(), + view.rows(), + view.as_mut_ptr(), + ) + } +} + +impl MemoryTrace { + /// Rows `[first_row, first_row + tile_rows)` of the padded trace, wrapping at + /// its height, written to `output` on `device`: the writer behind + /// [`TraceGenerator::write_device_rows`], reachable without a view. + fn write_tile( + &self, + device: i32, + first_row: usize, + tile_rows: usize, + output: *mut u64, + ) -> Result<(), String> { + let _span = tracing::info_span!( + "aiur/codegen_memory_rows", + device, + first = first_row, + rows = tile_rows, + width = self.width() + ) + .entered(); + let stride = self.stride(); + let mut done = 0; + let mut first = first_row % self.height; + while done < tile_rows { + let span = self.span(first.min(self.real - 1)); + let remaining = (tile_rows - done).min(self.height - first).min(MAX_ROWS); + let (rows, real, seeds) = if first >= self.real { + (remaining, 0, std::ptr::null()) + } else { + let rows = remaining.min(span.first + span.rows - first); + let offset = (first - span.first) * stride; + (rows, rows, span.bytes[offset..].as_ptr()) + }; + let status = unsafe { + aiur_trace_memory( + device, + seeds, + self.values, + real, + rows, + output.add(done * self.width()), + ) + }; + if status != 0 { + return Err(format!( + "generated memory table of width {}, row {first}: status {status}", + self.values + )); + } + done += rows; + first = (first + rows) % self.height; + } + Ok(()) + } + + /// The tile [`Self::write_tile`] writes on `device`, read back as raw + /// words. + #[cfg(test)] + pub(crate) fn download_tile( + &self, + device: i32, + first_row: usize, + tile_rows: usize, + ) -> Vec { + let words = tile_rows * self.width(); + let mut tile = std::ptr::null_mut(); + let status = unsafe { aiur_trace_tile_alloc(device, words, &mut tile) }; + assert_eq!(status, 0, "device tile allocation"); + let written = self.write_tile(device, first_row, tile_rows, tile); + let mut host = vec![0u64; words]; + let status = unsafe { + aiur_trace_tile_download(device, tile, words, host.as_mut_ptr()) + }; + written.expect("device writer"); + assert_eq!(status, 0, "device tile download"); + host + } +} diff --git a/crates/aiur/src/trace_codegen/programs/ix_aggr.rs b/crates/aiur/src/trace_codegen/programs/ix_aggr.rs new file mode 100644 index 000000000..057cef279 --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ix_aggr.rs @@ -0,0 +1,1921 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_86(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_86_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn write_86(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_86: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_117(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 116, &[v_0, v_1])?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 32] = context.load::<32>(2, v_4)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed[58] = v_58.as_canonical_u64(); seed[59] = v_59.as_canonical_u64(); seed[60] = v_60.as_canonical_u64(); seed[61] = v_61.as_canonical_u64(); seed[62] = v_62.as_canonical_u64(); seed[63] = v_63.as_canonical_u64(); seed[64] = v_64.as_canonical_u64(); seed[65] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113]: [G; 32] = context.call::<32>(21, 86, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed[66] = v_82.as_canonical_u64(); seed[67] = v_83.as_canonical_u64(); seed[68] = v_84.as_canonical_u64(); seed[69] = v_85.as_canonical_u64(); seed[70] = v_86.as_canonical_u64(); seed[71] = v_87.as_canonical_u64(); seed[72] = v_88.as_canonical_u64(); seed[73] = v_89.as_canonical_u64(); seed[74] = v_90.as_canonical_u64(); seed[75] = v_91.as_canonical_u64(); seed[76] = v_92.as_canonical_u64(); seed[77] = v_93.as_canonical_u64(); seed[78] = v_94.as_canonical_u64(); seed[79] = v_95.as_canonical_u64(); seed[80] = v_96.as_canonical_u64(); seed[81] = v_97.as_canonical_u64(); seed[82] = v_98.as_canonical_u64(); seed[83] = v_99.as_canonical_u64(); seed[84] = v_100.as_canonical_u64(); seed[85] = v_101.as_canonical_u64(); seed[86] = v_102.as_canonical_u64(); seed[87] = v_103.as_canonical_u64(); seed[88] = v_104.as_canonical_u64(); seed[89] = v_105.as_canonical_u64(); seed[90] = v_106.as_canonical_u64(); seed[91] = v_107.as_canonical_u64(); seed[92] = v_108.as_canonical_u64(); seed[93] = v_109.as_canonical_u64(); seed[94] = v_110.as_canonical_u64(); seed[95] = v_111.as_canonical_u64(); seed[96] = v_112.as_canonical_u64(); seed[97] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113])?; seed[98] = v_114.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 116, &[v_14, v_15])?; seed[18] = v_115.as_canonical_u64(); seed[19] = v_116.as_canonical_u64(); seed[20] = v_117.as_canonical_u64(); seed[21] = v_118.as_canonical_u64(); seed[22] = v_119.as_canonical_u64(); seed[23] = v_120.as_canonical_u64(); seed[24] = v_121.as_canonical_u64(); seed[25] = v_122.as_canonical_u64(); seed[26] = v_123.as_canonical_u64(); seed[27] = v_124.as_canonical_u64(); seed[28] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 116, &[v_123, v_124])?; seed[29] = v_126.as_canonical_u64(); seed[30] = v_127.as_canonical_u64(); seed[31] = v_128.as_canonical_u64(); seed[32] = v_129.as_canonical_u64(); seed[33] = v_130.as_canonical_u64(); seed[34] = v_131.as_canonical_u64(); seed[35] = v_132.as_canonical_u64(); seed[36] = v_133.as_canonical_u64(); seed[37] = v_134.as_canonical_u64(); seed[38] = v_135.as_canonical_u64(); seed[39] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 116, &[v_134, v_135])?; seed[40] = v_137.as_canonical_u64(); seed[41] = v_138.as_canonical_u64(); seed[42] = v_139.as_canonical_u64(); seed[43] = v_140.as_canonical_u64(); seed[44] = v_141.as_canonical_u64(); seed[45] = v_142.as_canonical_u64(); seed[46] = v_143.as_canonical_u64(); seed[47] = v_144.as_canonical_u64(); seed[48] = v_145.as_canonical_u64(); seed[49] = v_146.as_canonical_u64(); seed[50] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 116, &[v_145, v_146])?; seed[51] = v_148.as_canonical_u64(); seed[52] = v_149.as_canonical_u64(); seed[53] = v_150.as_canonical_u64(); seed[54] = v_151.as_canonical_u64(); seed[55] = v_152.as_canonical_u64(); seed[56] = v_153.as_canonical_u64(); seed[57] = v_154.as_canonical_u64(); seed[58] = v_155.as_canonical_u64(); seed[59] = v_156.as_canonical_u64(); seed[60] = v_157.as_canonical_u64(); seed[61] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 116, &[v_156, v_157])?; seed[62] = v_159.as_canonical_u64(); seed[63] = v_160.as_canonical_u64(); seed[64] = v_161.as_canonical_u64(); seed[65] = v_162.as_canonical_u64(); seed[66] = v_163.as_canonical_u64(); seed[67] = v_164.as_canonical_u64(); seed[68] = v_165.as_canonical_u64(); seed[69] = v_166.as_canonical_u64(); seed[70] = v_167.as_canonical_u64(); seed[71] = v_168.as_canonical_u64(); seed[72] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 116, &[v_167, v_168])?; seed[73] = v_170.as_canonical_u64(); seed[74] = v_171.as_canonical_u64(); seed[75] = v_172.as_canonical_u64(); seed[76] = v_173.as_canonical_u64(); seed[77] = v_174.as_canonical_u64(); seed[78] = v_175.as_canonical_u64(); seed[79] = v_176.as_canonical_u64(); seed[80] = v_177.as_canonical_u64(); seed[81] = v_178.as_canonical_u64(); seed[82] = v_179.as_canonical_u64(); seed[83] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 116, &[v_178, v_179])?; seed[84] = v_181.as_canonical_u64(); seed[85] = v_182.as_canonical_u64(); seed[86] = v_183.as_canonical_u64(); seed[87] = v_184.as_canonical_u64(); seed[88] = v_185.as_canonical_u64(); seed[89] = v_186.as_canonical_u64(); seed[90] = v_187.as_canonical_u64(); seed[91] = v_188.as_canonical_u64(); seed[92] = v_189.as_canonical_u64(); seed[93] = v_190.as_canonical_u64(); seed[94] = v_191.as_canonical_u64(); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed[95] = v_201.as_canonical_u64(); seed[96] = v_202.as_canonical_u64(); seed[97] = v_203.as_canonical_u64(); seed[98] = v_204.as_canonical_u64(); seed[99] = v_205.as_canonical_u64(); seed[100] = v_206.as_canonical_u64(); seed[101] = v_207.as_canonical_u64(); seed[102] = v_208.as_canonical_u64(); seed[103] = v_209.as_canonical_u64(); seed[104] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed[105] = v_211.as_canonical_u64(); seed[106] = v_212.as_canonical_u64(); seed[107] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed[108] = v_225.as_canonical_u64(); seed[109] = v_226.as_canonical_u64(); seed[110] = v_227.as_canonical_u64(); seed[111] = v_228.as_canonical_u64(); seed[112] = v_229.as_canonical_u64(); seed[113] = v_230.as_canonical_u64(); seed[114] = v_231.as_canonical_u64(); seed[115] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = context.call::<1>(52, 4, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed[116] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed[117] = v_241.as_canonical_u64(); seed[118] = v_242.as_canonical_u64(); seed[119] = v_243.as_canonical_u64(); seed[120] = v_244.as_canonical_u64(); seed[121] = v_245.as_canonical_u64(); seed[122] = v_246.as_canonical_u64(); seed[123] = v_247.as_canonical_u64(); seed[124] = v_248.as_canonical_u64(); seed[125] = v_249.as_canonical_u64(); seed[126] = v_250.as_canonical_u64(); seed[127] = v_251.as_canonical_u64(); seed[128] = v_252.as_canonical_u64(); seed[129] = v_253.as_canonical_u64(); seed[130] = v_254.as_canonical_u64(); seed[131] = v_255.as_canonical_u64(); seed[132] = v_256.as_canonical_u64(); seed[133] = v_257.as_canonical_u64(); seed[134] = v_258.as_canonical_u64(); seed[135] = v_259.as_canonical_u64(); seed[136] = v_260.as_canonical_u64(); seed[137] = v_261.as_canonical_u64(); seed[138] = v_262.as_canonical_u64(); seed[139] = v_263.as_canonical_u64(); seed[140] = v_264.as_canonical_u64(); seed[141] = v_265.as_canonical_u64(); seed[142] = v_266.as_canonical_u64(); seed[143] = v_267.as_canonical_u64(); seed[144] = v_268.as_canonical_u64(); seed[145] = v_269.as_canonical_u64(); seed[146] = v_270.as_canonical_u64(); seed[147] = v_271.as_canonical_u64(); seed[148] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 86, &[v_288, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed[149] = v_289.as_canonical_u64(); seed[150] = v_290.as_canonical_u64(); seed[151] = v_291.as_canonical_u64(); seed[152] = v_292.as_canonical_u64(); seed[153] = v_293.as_canonical_u64(); seed[154] = v_294.as_canonical_u64(); seed[155] = v_295.as_canonical_u64(); seed[156] = v_296.as_canonical_u64(); seed[157] = v_297.as_canonical_u64(); seed[158] = v_298.as_canonical_u64(); seed[159] = v_299.as_canonical_u64(); seed[160] = v_300.as_canonical_u64(); seed[161] = v_301.as_canonical_u64(); seed[162] = v_302.as_canonical_u64(); seed[163] = v_303.as_canonical_u64(); seed[164] = v_304.as_canonical_u64(); seed[165] = v_305.as_canonical_u64(); seed[166] = v_306.as_canonical_u64(); seed[167] = v_307.as_canonical_u64(); seed[168] = v_308.as_canonical_u64(); seed[169] = v_309.as_canonical_u64(); seed[170] = v_310.as_canonical_u64(); seed[171] = v_311.as_canonical_u64(); seed[172] = v_312.as_canonical_u64(); seed[173] = v_313.as_canonical_u64(); seed[174] = v_314.as_canonical_u64(); seed[175] = v_315.as_canonical_u64(); seed[176] = v_316.as_canonical_u64(); seed[177] = v_317.as_canonical_u64(); seed[178] = v_318.as_canonical_u64(); seed[179] = v_319.as_canonical_u64(); seed[180] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_322.as_canonical_u64(); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed[181] = v_355.as_canonical_u64(); seed[182] = v_356.as_canonical_u64(); seed[183] = v_357.as_canonical_u64(); seed[184] = v_358.as_canonical_u64(); seed[185] = v_359.as_canonical_u64(); seed[186] = v_360.as_canonical_u64(); seed[187] = v_361.as_canonical_u64(); seed[188] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 13, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed[189] = v_363.as_canonical_u64(); seed[190] = v_364.as_canonical_u64(); seed[191] = v_365.as_canonical_u64(); seed[192] = v_366.as_canonical_u64(); seed[193] = v_367.as_canonical_u64(); seed[194] = v_368.as_canonical_u64(); seed[195] = v_369.as_canonical_u64(); seed[196] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed[197] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed[198] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[199] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed[200] = v_374.as_canonical_u64(); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed[182] = v_378.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn pack_117_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 116, &[v_0, v_1])?; seed.u8(404, v_6); seed.u8(405, v_7); seed.u8(406, v_8); seed.u8(407, v_9); seed.u8(408, v_10); seed.u8(409, v_11); seed.u8(410, v_12); seed.u8(411, v_13); seed.u32(328, v_14); seed.u32(332, v_15); seed.u8(412, v_16); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed.full(24, v_17); seed.full(32, v_18); seed.full(40, v_19); seed.full(48, v_20); seed.full(56, v_21); seed.full(64, v_22); seed.full(72, v_23); seed.full(80, v_24); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 32] = context.load::<32>(2, v_4)?; seed.u32(336, v_25); seed.u32(340, v_26); seed.u8(413, v_27); seed.u8(414, v_28); seed.u8(415, v_29); seed.u8(416, v_30); seed.u8(417, v_31); seed.u8(418, v_32); seed.u8(419, v_33); seed.u8(420, v_34); seed.u8(421, v_35); seed.u32(344, v_36); seed.u32(348, v_37); seed.u8(422, v_38); seed.u8(423, v_39); seed.u8(424, v_40); seed.u8(425, v_41); seed.u8(426, v_42); seed.u8(427, v_43); seed.u8(428, v_44); seed.u8(429, v_45); seed.u8(430, v_46); seed.u32(352, v_47); seed.u32(356, v_48); seed.u8(431, v_49); seed.u8(432, v_50); seed.u8(433, v_51); seed.u8(434, v_52); seed.u8(435, v_53); seed.u8(436, v_54); seed.u8(437, v_55); seed.u8(438, v_56); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed.u8(439, v_58); seed.u32(360, v_59); seed.u32(364, v_60); seed.u8(440, v_61); seed.u8(441, v_62); seed.u8(442, v_63); seed.u8(443, v_64); seed.u8(444, v_65); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113]: [G; 32] = context.call::<32>(21, 86, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed.u8(445, v_82); seed.u8(446, v_83); seed.u8(447, v_84); seed.u8(448, v_85); seed.u32(368, v_86); seed.u32(372, v_87); seed.u8(449, v_88); seed.u8(450, v_89); seed.u8(451, v_90); seed.u8(452, v_91); seed.u8(453, v_92); seed.u8(454, v_93); seed.u8(455, v_94); seed.u8(456, v_95); seed.u8(457, v_96); seed.u32(376, v_97); seed.u32(380, v_98); seed.u8(458, v_99); seed.u8(459, v_100); seed.u8(460, v_101); seed.u8(461, v_102); seed.u8(462, v_103); seed.u8(463, v_104); seed.u8(464, v_105); seed.u8(465, v_106); seed.u8(466, v_107); seed.u32(384, v_108); seed.u32(388, v_109); seed.u8(467, v_110); seed.u8(468, v_111); seed.full(88, v_112); seed.full(96, v_113); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113])?; seed.full(104, v_114); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 116, &[v_14, v_15])?; seed.full(24, v_115); seed.full(32, v_116); seed.full(40, v_117); seed.full(48, v_118); seed.full(56, v_119); seed.full(64, v_120); seed.full(72, v_121); seed.full(80, v_122); seed.u32(336, v_123); seed.u32(340, v_124); seed.u8(413, v_125); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 116, &[v_123, v_124])?; seed.u8(414, v_126); seed.u8(415, v_127); seed.u8(416, v_128); seed.u8(417, v_129); seed.u8(418, v_130); seed.u8(419, v_131); seed.u8(420, v_132); seed.u8(421, v_133); seed.u32(344, v_134); seed.u32(348, v_135); seed.u8(422, v_136); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 116, &[v_134, v_135])?; seed.u8(423, v_137); seed.u8(424, v_138); seed.u8(425, v_139); seed.u8(426, v_140); seed.u8(427, v_141); seed.u8(428, v_142); seed.u8(429, v_143); seed.u8(430, v_144); seed.u32(352, v_145); seed.u32(356, v_146); seed.u8(431, v_147); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 116, &[v_145, v_146])?; seed.u8(432, v_148); seed.u8(433, v_149); seed.u8(434, v_150); seed.u8(435, v_151); seed.u8(436, v_152); seed.u8(437, v_153); seed.u8(438, v_154); seed.u8(439, v_155); seed.u32(360, v_156); seed.u32(364, v_157); seed.u8(440, v_158); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 116, &[v_156, v_157])?; seed.u8(441, v_159); seed.u8(442, v_160); seed.u8(443, v_161); seed.u8(444, v_162); seed.u8(445, v_163); seed.u8(446, v_164); seed.u8(447, v_165); seed.u8(448, v_166); seed.u32(368, v_167); seed.u32(372, v_168); seed.u8(449, v_169); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 116, &[v_167, v_168])?; seed.u8(450, v_170); seed.u8(451, v_171); seed.u8(452, v_172); seed.u8(453, v_173); seed.u8(454, v_174); seed.u8(455, v_175); seed.u8(456, v_176); seed.u8(457, v_177); seed.u32(376, v_178); seed.u32(380, v_179); seed.u8(458, v_180); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 116, &[v_178, v_179])?; seed.u8(459, v_181); seed.u8(460, v_182); seed.u8(461, v_183); seed.u8(462, v_184); seed.u8(463, v_185); seed.u8(464, v_186); seed.u8(465, v_187); seed.u8(466, v_188); seed.u32(384, v_189); seed.u32(388, v_190); seed.u8(467, v_191); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed.u8(468, v_201); seed.full(88, v_202); seed.full(96, v_203); seed.full(104, v_204); seed.full(112, v_205); seed.full(120, v_206); seed.full(128, v_207); seed.full(136, v_208); seed.full(144, v_209); seed.full(152, v_210); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed.u8(469, v_211); seed.full(160, v_212); seed.full(168, v_213); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed.u8(470, v_225); seed.u8(471, v_226); seed.u8(472, v_227); seed.u8(473, v_228); seed.u8(474, v_229); seed.u8(475, v_230); seed.u8(476, v_231); seed.u8(477, v_232); let [v_233]: [G; 1] = context.call::<1>(52, 4, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed.u8(478, v_233); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed.u8(479, v_241); seed.u8(480, v_242); seed.u8(481, v_243); seed.u8(482, v_244); seed.u8(483, v_245); seed.u8(484, v_246); seed.u8(485, v_247); seed.u8(486, v_248); seed.u8(487, v_249); seed.u8(488, v_250); seed.u8(489, v_251); seed.u8(490, v_252); seed.u8(491, v_253); seed.u8(492, v_254); seed.u8(493, v_255); seed.u8(494, v_256); seed.u8(495, v_257); seed.u8(496, v_258); seed.u8(497, v_259); seed.u8(498, v_260); seed.u8(499, v_261); seed.u8(500, v_262); seed.u8(501, v_263); seed.u8(502, v_264); seed.u8(503, v_265); seed.u8(504, v_266); seed.u8(505, v_267); seed.u8(506, v_268); seed.u8(507, v_269); seed.u8(508, v_270); seed.u8(509, v_271); seed.u8(510, v_272); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 86, &[v_288, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed.u8(511, v_289); seed.u8(512, v_290); seed.u8(513, v_291); seed.u8(514, v_292); seed.u8(515, v_293); seed.u8(516, v_294); seed.u8(517, v_295); seed.u8(518, v_296); seed.u8(519, v_297); seed.u8(520, v_298); seed.u8(521, v_299); seed.u8(522, v_300); seed.u8(523, v_301); seed.u8(524, v_302); seed.u8(525, v_303); seed.u8(526, v_304); seed.u8(527, v_305); seed.u8(528, v_306); seed.u8(529, v_307); seed.u8(530, v_308); seed.u8(531, v_309); seed.u8(532, v_310); seed.u8(533, v_311); seed.u8(534, v_312); seed.u8(535, v_313); seed.u8(536, v_314); seed.u8(537, v_315); seed.u8(538, v_316); seed.u8(539, v_317); seed.u8(540, v_318); seed.u8(541, v_319); seed.u8(542, v_320); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_322); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed.full(176, v_355); seed.full(184, v_356); seed.full(192, v_357); seed.full(200, v_358); seed.full(208, v_359); seed.full(216, v_360); seed.full(224, v_361); seed.full(232, v_362); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 13, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed.full(240, v_363); seed.full(248, v_364); seed.full(256, v_365); seed.full(264, v_366); seed.full(272, v_367); seed.full(280, v_368); seed.full(288, v_369); seed.full(296, v_370); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed.u32(392, v_371); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed.u32(396, v_372); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.u32(400, v_373); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed.full(304, v_374); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_377); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed.full(184, v_378); Ok(()) }, } }, } }, } } + +fn write_117(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 32] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57])]; row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_56.as_canonical_u64(); let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65])]; row[offsets.auxiliaries + 52] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_65.as_canonical_u64(); let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113]: [G; 32] = [G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 60] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = [G::from_u64(seed[98])]; row[offsets.auxiliaries + 92] = v_114.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 20] = (v_24 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_23 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_20 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_19 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_18 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_17 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 12] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 13] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39])]; row[offsets.auxiliaries + 24] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = [G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 35] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = [G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 46] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 57] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83])]; row[offsets.auxiliaries + 68] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = [G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 79] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_191.as_canonical_u64(); let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104])]; row[offsets.auxiliaries + 90] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = [G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107])]; row[offsets.auxiliaries + 100] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); break 'yield_0 [v_214]; }, _ => { row[offsets.auxiliaries + 103] = (v_211 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); break 'yield_0 [v_215]; }, } }, _ => { row[offsets.auxiliaries + 100] = (v_201 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_216]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); break 'yield_0 [v_216]; }, } }; row[offsets.auxiliaries + 104] = v_217.as_canonical_u64(); let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; row[offsets.auxiliaries + 105] = g_inverse_value(v_219).as_canonical_u64(); row[offsets.auxiliaries + 106] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; row[offsets.auxiliaries + 107] = g_inverse_value(v_2).as_canonical_u64(); row[offsets.auxiliaries + 108] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_217 * v_220]; row[offsets.auxiliaries + 109] = v_222.as_canonical_u64(); let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = [G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 110] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [G::from_u64(seed[116])]; row[offsets.auxiliaries + 118] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; row[offsets.auxiliaries + 119] = v_234.as_canonical_u64(); let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = [G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 120] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_264.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_272.as_canonical_u64(); let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163]), G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166]), G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169]), G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172]), G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175]), G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178]), G::from_u64(seed[179]), G::from_u64(seed[180])]; row[offsets.auxiliaries + 152] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 154] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 157] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_297.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_298.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_299.as_canonical_u64(); row[offsets.auxiliaries + 163] = v_300.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_304.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_305.as_canonical_u64(); row[offsets.auxiliaries + 169] = v_306.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_308.as_canonical_u64(); row[offsets.auxiliaries + 172] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_310.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_312.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_314.as_canonical_u64(); row[offsets.auxiliaries + 178] = v_315.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_316.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_317.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_318.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_322]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 184] = v_322.as_canonical_u64(); row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 184] = (v_217 - G::from_u64(1)).inverse().as_canonical_u64(); match v_220.as_canonical_u64() { 1u64 => { let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = [G::from_u64(seed[181]), G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184]), G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187]), G::from_u64(seed[188])]; row[offsets.auxiliaries + 185] = v_355.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_356.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_357.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_358.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_359.as_canonical_u64(); row[offsets.auxiliaries + 190] = v_360.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_361.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = [G::from_u64(seed[189]), G::from_u64(seed[190]), G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193]), G::from_u64(seed[194]), G::from_u64(seed[195]), G::from_u64(seed[196])]; row[offsets.auxiliaries + 193] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 194] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 195] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 196] = v_366.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_367.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_368.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 200] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = [G::from_u64(seed[197])]; row[offsets.auxiliaries + 201] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = [G::from_u64(seed[198])]; row[offsets.auxiliaries + 202] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = [G::from_u64(seed[199])]; row[offsets.auxiliaries + 203] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = [G::from_u64(seed[200])]; row[offsets.auxiliaries + 204] = v_374.as_canonical_u64(); row[offsets.selectors + 13] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 185] = (v_220 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_377]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 186] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = [G::from_u64(seed[182])]; row[offsets.auxiliaries + 187] = v_378.as_canonical_u64(); row[offsets.selectors + 14] = G::ONE.as_canonical_u64(); }, } }, } }, } } + +static SCHEMA_117: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 312, 316, 8, 320, 324, 16, 404, 405, 406, 407, 408, 409, 410, 411, 328, 332, 412, 24, 32, 40, 48, 56, 64, 72, 80, 336, 340, 413, 414, 415, 416, 417, 418, 419, 420, 421, 344, 348, 422, 423, 424, 425, 426, 427, 428, 429, 430, 352, 356, 431, 432, 433, 434, 435, 436, 437, 438, 439, 360, 364, 440, 441, 442, 443, 444, 445, 446, 447, 448, 368, 372, 449, 450, 451, 452, 453, 454, 455, 456, 457, 376, 380, 458, 459, 460, 461, 462, 463, 464, 465, 466, 384, 388, 467, 468, 88, 96, 104, 112, 120, 128, 136, 144, 152, 469, 160, 168, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 392, 396, 400, 304], bytes: 544 }; + +fn pack_220(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed[6] = v_9.as_canonical_u64(); seed[7] = v_10.as_canonical_u64(); seed[8] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 219, &[v_3, v_10])?; seed[9] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed[10] = v_14.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +fn pack_220_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_2); seed.u32(16, v_3); seed.u32(20, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed.u8(33, v_5); seed.u32(24, v_6); seed.u32(28, v_7); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed.u8(33, v_9); seed.u32(24, v_10); seed.u32(28, v_11); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 219, &[v_3, v_10])?; seed.u8(34, v_12); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed.u8(35, v_14); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +fn write_220(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_14.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(220, v_9)) }, } }, _ => { Err(no_match(220, v_2)) }, } } + +static SCHEMA_220: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 32, 16, 20, 33, 24, 28, 34, 35], bytes: 40 }; + +fn pack_230(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 229, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 229, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 229, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 229, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 229, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 229, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 229, &[v_6, v_14, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed[24] = v_24.as_canonical_u64(); Ok(()) } + +fn pack_230_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 229, &[v_0, v_8, v_16])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(2, 229, &[v_1, v_9, v_17])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(3, 229, &[v_2, v_10, v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.call::<1>(4, 229, &[v_3, v_11, v_19])?; seed.full(32, v_20); let [v_21]: [G; 1] = context.call::<1>(5, 229, &[v_4, v_12, v_20])?; seed.full(40, v_21); let [v_22]: [G; 1] = context.call::<1>(6, 229, &[v_5, v_13, v_21])?; seed.full(48, v_22); let [v_23]: [G; 1] = context.call::<1>(7, 229, &[v_6, v_14, v_22])?; seed.full(56, v_23); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed.full(64, v_24); Ok(()) } + +fn write_230(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_17]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_230: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 8, 16, 24, 32, 40, 48, 56, 64], bytes: 88 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(256)), Op::Mul(9, 66), Op::Add(67, 8), Op::Mul(68, 66), Op::Add(69, 7), Op::Mul(70, 66), Op::Add(71, 6), Op::Mul(72, 66), Op::Add(73, 5), Op::Mul(74, 66), Op::Add(75, 4), Op::Mul(76, 66), Op::Add(77, 3), Op::Mul(41, 66), Op::Add(79, 40), Op::Mul(80, 66), Op::Add(81, 39), Op::Mul(82, 66), Op::Add(83, 38), Op::Mul(84, 66), Op::Add(85, 37), Op::Mul(86, 66), Op::Add(87, 36), Op::Mul(88, 66), Op::Add(89, 35), Op::Sub(78, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 92), Op::Add(93, 15), Op::Mul(94, 92), Op::Add(95, 14), Op::Mul(96, 92), Op::Add(97, 13), Op::Mul(98, 92), Op::Add(99, 12), Op::Mul(100, 92), Op::Add(101, 11), Op::Mul(102, 92), Op::Add(103, 10), Op::Mul(48, 92), Op::Add(105, 47), Op::Mul(106, 92), Op::Add(107, 46), Op::Mul(108, 92), Op::Add(109, 45), Op::Mul(110, 92), Op::Add(111, 44), Op::Mul(112, 92), Op::Add(113, 43), Op::Mul(114, 92), Op::Add(115, 42), Op::Sub(104, 116)], ctrl: Ctrl::Match(117, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(23, 118), Op::Add(119, 22), Op::Mul(120, 118), Op::Add(121, 21), Op::Mul(122, 118), Op::Add(123, 20), Op::Mul(124, 118), Op::Add(125, 19), Op::Mul(126, 118), Op::Add(127, 18), Op::Mul(128, 118), Op::Add(129, 17), Op::Mul(55, 118), Op::Add(131, 54), Op::Mul(132, 118), Op::Add(133, 53), Op::Mul(134, 118), Op::Add(135, 52), Op::Mul(136, 118), Op::Add(137, 51), Op::Mul(138, 118), Op::Add(139, 50), Op::Mul(140, 118), Op::Add(141, 49), Op::Sub(130, 142)], ctrl: Ctrl::Match(143, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(30, 144), Op::Add(145, 29), Op::Mul(146, 144), Op::Add(147, 28), Op::Mul(148, 144), Op::Add(149, 27), Op::Mul(150, 144), Op::Add(151, 26), Op::Mul(152, 144), Op::Add(153, 25), Op::Mul(154, 144), Op::Add(155, 24), Op::Mul(62, 144), Op::Add(157, 61), Op::Mul(158, 144), Op::Add(159, 60), Op::Mul(160, 144), Op::Add(161, 59), Op::Mul(162, 144), Op::Add(163, 58), Op::Mul(164, 144), Op::Add(165, 57), Op::Mul(166, 144), Op::Add(167, 56), Op::Sub(156, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(33, 170), Op::Add(171, 32), Op::Mul(172, 170), Op::Add(173, 31), Op::Mul(65, 170), Op::Add(175, 64), Op::Mul(176, 170), Op::Add(177, 63), Op::Sub(174, 178)], ctrl: Ctrl::Match(179, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![180]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![180]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![170]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![144]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![118]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![92]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 66, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Sub(2, 34)], ctrl: Ctrl::Match(66, [(G::from_u64(0), Block { ops: vec![Op::Call(1, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![67]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![67]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 66, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Sub(2, 3), Op::Call(3, vec![0, 4, 5], 1, false), Op::IORead(0, 1, 1), Op::Const(G::from_u64(0)), Op::Store(vec![8, 7, 6])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Mul(12, 12), Op::AssertEq(vec![13], vec![12], Some("u32_add: carry is not boolean".into()))], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::U8RangeCheck(12, 13), Op::U8RangeCheck(14, 15), Op::Const(G::from_u64(1)), Op::Sub(16, 17), Op::Const(G::from_u64(2)), Op::Sub(16, 19), Op::Mul(18, 20), Op::Mul(16, 21), Op::Const(G::from_u64(0)), Op::AssertEq(vec![22], vec![23], Some("u32_add3: carry is not in {0, 1, 2}".into()))], ctrl: Ctrl::Return(0, vec![12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 4), Op::U8Xor(1, 5), Op::U8Xor(2, 6), Op::U8Xor(3, 7)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 0, 1]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 0]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit7(0, 4), Op::U8XorSplit7(1, 5), Op::U8XorSplit7(2, 6), Op::U8XorSplit7(3, 7), Op::Add(8, 11), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit4(0, 4), Op::U8XorSplit4(1, 5), Op::U8XorSplit4(2, 6), Op::U8XorSplit4(3, 7), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9), Op::Add(8, 11)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 8), Op::Sub(1, 9), Op::Sub(2, 10), Op::Sub(3, 11), Op::Sub(4, 12), Op::Sub(5, 13), Op::Sub(6, 14), Op::Sub(7, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![24]) }))) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(255), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".into())), Op::Const(G::from_u64(256)), Op::Mul(9, 1), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Const(G::from_u64(16777216)), Op::Mul(13, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 6), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(0, 25)], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(8, 1), Op::Const(G::from_u64(65536)), Op::Mul(10, 2), Op::Const(G::from_u64(16777216)), Op::Mul(12, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(14, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(16, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(18, 6), Op::Const(G::from_u64(72057594037927936)), Op::Mul(20, 7), Op::Add(19, 21), Op::Add(17, 22), Op::Add(15, 23), Op::Add(13, 24), Op::Add(11, 25), Op::Add(9, 26), Op::Add(0, 27)], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1020)), Op::Sub(7, 8), Op::Add(6, 9), Op::Add(5, 10), Op::Add(4, 11), Op::EqZero(12), Op::Add(2, 3), Op::Add(1, 14), Op::Add(0, 15), Op::EqZero(16), Op::Const(G::from_u64(1)), Op::Sub(18, 17), Op::Mul(13, 19), Op::Sub(18, 20)], ctrl: Ctrl::Return(0, vec![21]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::Const(G::from_u64(256)), Op::Mul(9, 2), Op::Const(G::from_u64(65536)), Op::Mul(11, 3), Op::Const(G::from_u64(16777216)), Op::Mul(13, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(21, 8), Op::Add(20, 22), Op::Add(18, 23), Op::Add(16, 24), Op::Add(14, 25), Op::Add(12, 26), Op::Add(10, 27), Op::Add(1, 28), Op::AssertEq(vec![29], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(8, 30), Op::Add(7, 31), Op::Add(6, 32), Op::Add(5, 33), Op::EqZero(34), Op::Add(3, 4), Op::Add(2, 36), Op::Add(1, 37), Op::EqZero(38), Op::Const(G::from_u64(1)), Op::Sub(40, 39), Op::Mul(35, 41), Op::Sub(40, 42), Op::AssertEq(vec![43], vec![40], None)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGInverse(0), Op::Mul(0, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 3), Op::Mul(0, 4), Op::Const(G::from_u64(0)), Op::AssertEq(vec![5], vec![6], None), Op::Mul(1, 4), Op::AssertEq(vec![7], vec![6], None)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![Op::Add(0, 2), Op::Add(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::Sub(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(2, 0), Op::Sub(2, 1)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_22() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(5, 6), Op::Add(4, 7), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(9, 10)], ctrl: Ctrl::Return(0, vec![8, 11]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_23() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(3, 4), Op::Sub(2, 5), Op::UnconstrainedGInverse(6), Op::Mul(6, 7), Op::Const(G::from_u64(1)), Op::Sub(8, 9), Op::Mul(6, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], None), Op::Mul(7, 10), Op::AssertEq(vec![13], vec![12], None), Op::Mul(0, 7), Op::Sub(12, 1), Op::Mul(15, 7)], ctrl: Ctrl::Return(0, vec![14, 16]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_24() -> Function { + Function { body: Block { ops: vec![Op::Mul(2, 2), Op::Const(G::from_u64(7)), Op::Mul(3, 3), Op::Mul(5, 6), Op::Sub(4, 7), Op::UnconstrainedGInverse(8), Op::Mul(8, 9), Op::Const(G::from_u64(1)), Op::Sub(10, 11), Op::Mul(8, 12), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], None), Op::Mul(9, 12), Op::AssertEq(vec![15], vec![14], None), Op::Mul(2, 9), Op::Sub(14, 3), Op::Mul(17, 9), Op::Mul(0, 16), Op::Mul(1, 18), Op::Mul(5, 20), Op::Add(19, 21), Op::Mul(0, 18), Op::Mul(1, 16), Op::Add(23, 24)], ctrl: Ctrl::Return(0, vec![22, 25]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 13, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_25() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::EqZero(4), Op::Sub(1, 3), Op::EqZero(6), Op::Mul(5, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_26() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![4, 6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_27() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(26, vec![2], 2, false), Op::Call(26, vec![4], 2, false), Op::Call(26, vec![6], 2, false), Op::Call(26, vec![8], 2, false), Op::Call(26, vec![10], 2, false), Op::Call(26, vec![12], 2, false), Op::Call(26, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_28() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 9, false), Op::Call(14, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_29() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 1), Op::Const(G::from_u64(1)), Op::Add(0, 3)], ctrl: Ctrl::Return(0, vec![2, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_30() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 8), Op::Const(G::from_u64(8)), Op::Add(0, 10)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_31() -> Function { + Function { body: Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(14, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_32() -> Function { + Function { body: Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![9], 9, true), Op::Const(G::from_u64(256)), Op::Mul(19, 2), Op::Const(G::from_u64(65536)), Op::Mul(21, 3), Op::Const(G::from_u64(16777216)), Op::Mul(23, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(25, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(27, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(29, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 8), Op::Add(30, 32), Op::Add(28, 33), Op::Add(26, 34), Op::Add(24, 35), Op::Add(22, 36), Op::Add(20, 37), Op::Add(1, 38), Op::Mul(19, 11), Op::Mul(21, 12), Op::Mul(23, 13), Op::Mul(25, 14), Op::Mul(27, 15), Op::Mul(29, 16), Op::Mul(31, 17), Op::Add(45, 46), Op::Add(44, 47), Op::Add(43, 48), Op::Add(42, 49), Op::Add(41, 50), Op::Add(40, 51), Op::Add(10, 52)], ctrl: Ctrl::Return(0, vec![39, 53, 18]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 19, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_33() -> Function { + Function { body: Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![9], 9, true), Op::Call(30, vec![18], 9, true), Op::Call(30, vec![27], 9, true)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_34() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_35() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, true), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(35, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_36() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(37, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_37() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(37, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_38() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(39, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_39() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![10], 9, true), Op::Const(G::from_u64(256)), Op::Mul(20, 3), Op::Const(G::from_u64(65536)), Op::Mul(22, 4), Op::Const(G::from_u64(16777216)), Op::Mul(24, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(26, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(28, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(30, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(32, 9), Op::Add(31, 33), Op::Add(29, 34), Op::Add(27, 35), Op::Add(25, 36), Op::Add(23, 37), Op::Add(21, 38), Op::Add(2, 39), Op::Mul(20, 12), Op::Mul(22, 13), Op::Mul(24, 14), Op::Mul(26, 15), Op::Mul(28, 16), Op::Mul(30, 17), Op::Mul(32, 18), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(11, 53), Op::Const(G::from_u64(1)), Op::Sub(1, 55), Op::Call(39, vec![19, 56], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![59, 40, 54, 57])], ctrl: Ctrl::Return(1, vec![60, 58]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_40() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(41, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_41() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(30, vec![0], 9, true), Op::Call(30, vec![10], 9, true), Op::Call(30, vec![19], 9, true), Op::Call(30, vec![28], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(41, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_42() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(43, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_43() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(43, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_44() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(45, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_45() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(43, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(45, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_46() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(47, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_47() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(38, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(47, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_48() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(49, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_49() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(46, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(49, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_50() -> Function { + Function { body: Block { ops: vec![Op::Call(40, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_51() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(52, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_52() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(40, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(52, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_53() -> Function { + Function { body: Block { ops: vec![Op::Call(40, vec![0], 2, false), Op::Call(40, vec![2], 2, false), Op::Call(40, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_54() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(45, vec![2, 1], 2, false), Op::Call(40, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_55() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(56, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_56() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(45, vec![3, 2], 2, false), Op::Call(40, vec![5], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(56, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_57() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, true), Op::Call(31, vec![2], 2, false), Op::Call(47, vec![4, 3], 2, false), Op::Call(40, vec![6], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_58() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(59, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_59() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, true), Op::Call(31, vec![3], 2, false), Op::Call(47, vec![5, 4], 2, false), Op::Call(40, vec![7], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(59, vec![9, 11], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 2, 6, 8, 12])], ctrl: Ctrl::Return(1, vec![15, 13]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_60() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(52, vec![2, 1], 2, false), Op::Call(36, vec![4], 2, false), Op::Call(31, vec![6], 2, false), Op::Call(56, vec![8, 7], 2, false), Op::Call(31, vec![10], 2, false), Op::Call(59, vec![12, 11], 2, false), Op::Call(38, vec![14], 2, false), Op::Call(30, vec![16], 9, true)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 26, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_61() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, true)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(48, vec![2], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_62() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false), Op::Call(40, vec![4], 2, false), Op::Call(40, vec![6], 2, false), Op::Call(40, vec![8], 2, false), Op::Call(38, vec![10], 2, false), Op::Call(31, vec![12], 2, false), Op::Call(35, vec![14, 13], 2, false), Op::Call(31, vec![16], 2, false), Op::Call(52, vec![18, 17], 2, false), Op::Call(36, vec![20], 2, false), Op::Call(31, vec![22], 2, false), Op::Call(56, vec![24, 23], 2, false), Op::Call(31, vec![26], 2, false), Op::Call(59, vec![28, 27], 2, false), Op::Call(38, vec![30], 2, false), Op::Call(30, vec![32], 9, true), Op::Call(48, vec![41], 2, false), Op::Call(61, vec![43], 3, false), Op::Call(48, vec![46], 2, false), Op::Call(48, vec![48], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 7, 9, 11, 15, 19, 21, 25, 29, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 44, 45, 47, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_63() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false), Op::Call(40, vec![4], 2, false), Op::Call(31, vec![6], 2, false), Op::Call(35, vec![8, 7], 2, false), Op::Call(31, vec![10], 2, false), Op::Call(43, vec![12, 11], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 14]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_64() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(65, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_65() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(35, vec![3, 2], 2, false), Op::Call(40, vec![5], 2, false), Op::Call(31, vec![7], 2, false), Op::Call(35, vec![9, 8], 2, false), Op::Call(31, vec![11], 2, false), Op::Call(43, vec![13, 12], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 16), Op::Call(65, vec![15, 17], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![20, 4, 6, 10, 14, 18])], ctrl: Ctrl::Return(1, vec![21, 19]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_66() -> Function { + Function { body: Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Call(30, vec![2], 9, true)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_67() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(68, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_68() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Call(30, vec![3], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Call(68, vec![12, 14], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![17, 2, 4, 5, 6, 7, 8, 9, 10, 11, 15])], ctrl: Ctrl::Return(1, vec![18, 16]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_69() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(70, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_70() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(62, vec![0], 25, false), Op::Const(G::from_u64(1)), Op::Sub(1, 27), Op::Call(70, vec![26, 28], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![31, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 29])], ctrl: Ctrl::Return(1, vec![32, 30]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_71() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![0], 2, false), Op::Call(65, vec![2, 1], 2, false), Op::Call(31, vec![4], 2, false), Op::Call(68, vec![6, 5], 2, false), Op::Call(31, vec![8], 2, false), Op::Call(70, vec![10, 9], 2, false)], ctrl: Ctrl::Return(0, vec![3, 7, 11, 12]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 13, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_72() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Const(G::from_u64(65536)), Op::Mul(6, 2), Op::Const(G::from_u64(16777216)), Op::Mul(8, 3), Op::Add(7, 9), Op::Add(5, 10), Op::Add(0, 11)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_73() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Const(G::from_u64(65536)), Op::Mul(34, 2), Op::Const(G::from_u64(16777216)), Op::Mul(36, 3), Op::Add(35, 37), Op::Add(33, 38), Op::Add(0, 39), Op::Mul(32, 5), Op::Mul(34, 6), Op::Mul(36, 7), Op::Add(42, 43), Op::Add(41, 44), Op::Add(4, 45), Op::Mul(32, 9), Op::Mul(34, 10), Op::Mul(36, 11), Op::Add(48, 49), Op::Add(47, 50), Op::Add(8, 51), Op::Mul(32, 13), Op::Mul(34, 14), Op::Mul(36, 15), Op::Add(54, 55), Op::Add(53, 56), Op::Add(12, 57), Op::Mul(32, 17), Op::Mul(34, 18), Op::Mul(36, 19), Op::Add(60, 61), Op::Add(59, 62), Op::Add(16, 63), Op::Mul(32, 21), Op::Mul(34, 22), Op::Mul(36, 23), Op::Add(66, 67), Op::Add(65, 68), Op::Add(20, 69), Op::Mul(32, 25), Op::Mul(34, 26), Op::Mul(36, 27), Op::Add(72, 73), Op::Add(71, 74), Op::Add(24, 75), Op::Mul(32, 29), Op::Mul(34, 30), Op::Mul(36, 31), Op::Add(78, 79), Op::Add(77, 80), Op::Add(28, 81)], ctrl: Ctrl::Return(0, vec![40, 46, 52, 58, 64, 70, 76, 82]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_74() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(78, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(77, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_75() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(78, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(77, vec![38], 32, false), Op::Store(vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70])], ctrl: Ctrl::Return(0, vec![71]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 39, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_76() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![68, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(76, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68], 34, false)], ctrl: Ctrl::Match(69, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![103, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 102]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(34, 102)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Mul(104, 33), Op::Add(103, 170), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![172, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 174, 175, 176, 177, 178, 179, 174, 180, 181, 182, 183, 184, 185, 186, 187, 188, 172, 172, 172, 172, 172, 172, 172, 172, 173, 172, 172, 172, 171, 172, 172, 172, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![172, 102, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220])], ctrl: Ctrl::Return(2, vec![172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 221]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![170, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 172, 173, 174, 175, 176, 177, 172, 178, 179, 180, 181, 182, 183, 184, 185, 186, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 170, 170, 103, 170, 170, 170, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![170, 102, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218])], ctrl: Ctrl::Return(3, vec![170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 219]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_77() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(34, 2)], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(76, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 69], 34, false)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Call(77, vec![103], 32, false)], ctrl: Ctrl::Return(1, vec![104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![104, 103, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]), Op::Call(77, vec![105], 32, false)], ctrl: Ctrl::Return(2, vec![106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_78() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![1, 2, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 1])], ctrl: Ctrl::Match(2, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![9, 11, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 12), Op::Add(3, 12), Op::Call(78, vec![9, 11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_79() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 96)], ctrl: Ctrl::Match(97, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 99)], ctrl: Ctrl::Match(100, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 102)], ctrl: Ctrl::Match(103, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 105)], ctrl: Ctrl::Match(106, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 108)], ctrl: Ctrl::Match(109, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 111)], ctrl: Ctrl::Match(112, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 114)], ctrl: Ctrl::Match(115, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 117)], ctrl: Ctrl::Match(118, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 123)], ctrl: Ctrl::Match(124, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 126)], ctrl: Ctrl::Match(127, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 129)], ctrl: Ctrl::Match(130, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 132)], ctrl: Ctrl::Match(133, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 135)], ctrl: Ctrl::Match(136, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 138)], ctrl: Ctrl::Match(139, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 141)], ctrl: Ctrl::Match(142, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 144)], ctrl: Ctrl::Match(145, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 147)], ctrl: Ctrl::Match(148, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 150)], ctrl: Ctrl::Match(151, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 153)], ctrl: Ctrl::Match(154, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 156)], ctrl: Ctrl::Match(157, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 159)], ctrl: Ctrl::Match(160, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 165)], ctrl: Ctrl::Match(166, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 171)], ctrl: Ctrl::Match(172, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 174)], ctrl: Ctrl::Match(175, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 177)], ctrl: Ctrl::Match(178, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 180)], ctrl: Ctrl::Match(181, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 183)], ctrl: Ctrl::Match(184, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 186)], ctrl: Ctrl::Match(187, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 189)], ctrl: Ctrl::Match(190, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_80() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(80, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_81() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Add(6, 7), Op::Add(8, 17), Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![51, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 60, 61, 62, 63, 64, 65, 60, 66, 67, 68, 69, 70, 71, 72, 73, 74, 52, 53, 54, 55, 56, 57, 58, 59, 51, 51, 51, 51, 18, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51], 32, false), Op::Store(vec![51, 5, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106])], ctrl: Ctrl::Return(0, vec![107]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Load(32, 4), Op::Store(vec![9, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41])], ctrl: Ctrl::Return(9, vec![42]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(8, 3), Op::Call(4, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Sub(2, 1), Op::EqZero(19), Op::Mul(20, 6), Op::Add(18, 21), Op::Add(7, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(80, vec![0, 25], 1, false), Op::Call(79, vec![26], 64, false), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![138, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 123, 129, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 14, 15, 16, 1, 138, 138, 138, 23, 138, 138, 138, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90], 32, false), Op::Store(vec![138, 5, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170])], ctrl: Ctrl::Return(10, vec![171]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_82() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(79, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(304, vec![0], 1, false), Op::Load(8, 3), Op::Call(4, vec![74, 75, 76, 77, 78, 79, 80, 81], 1, false), Op::Mul(73, 82), Op::Mul(8, 83), Op::Add(84, 7), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(0)), Op::Call(86, vec![150, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 74, 75, 76, 77, 78, 79, 80, 81, 149, 150, 150, 150, 85, 150, 150, 150, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Store(vec![150, 5, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182]), Op::Const(G::from_u64(1)), Op::Store(vec![184, 184, 184]), Op::Call(13, vec![74, 75, 76, 77, 78, 79, 80, 81], 8, false), Op::Store(vec![186, 187, 188, 189, 190, 191, 192, 193]), Op::Store(vec![86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]), Op::Call(78, vec![0, 185, 150, 150, 194, 195, 183], 1, false)], ctrl: Ctrl::Return(0, vec![196]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(304, vec![0], 1, false), Op::Mul(73, 7), Op::Call(304, vec![0], 1, false), Op::Load(8, 3), Op::Call(4, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(84, 8), Op::Mul(75, 85), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(86, 90), Op::Add(74, 91), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![141, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131, 126, 132, 133, 134, 135, 136, 137, 138, 139, 140, 76, 77, 78, 79, 80, 81, 82, 83, 125, 141, 141, 141, 92, 141, 141, 141, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Const(G::from_u64(1)), Op::Store(vec![174, 174, 174]), Op::Add(2, 174), Op::Store(vec![142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173]), Op::Call(78, vec![0, 175, 141, 176, 3, 177, 5], 1, false)], ctrl: Ctrl::Return(1, vec![178]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_83() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![16, 17, 18, 19]), Op::U8RangeCheck(24, 25), Op::U8RangeCheck(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Const(G::from_u64(2)), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(28, 33), Op::Const(G::from_u64(0)), Op::AssertEq(vec![34], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(12, 24), Op::U8Xor(13, 25), Op::U8Xor(14, 26), Op::U8Xor(15, 27), Op::UnconstrainedU32Add(vec![8, 9, 10, 11], vec![38, 39, 36, 37]), Op::U8RangeCheck(40, 41), Op::U8RangeCheck(42, 43), Op::Mul(44, 44), Op::AssertEq(vec![45], vec![44], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(4, 40), Op::U8XorSplit4(5, 41), Op::U8XorSplit4(6, 42), Op::U8XorSplit4(7, 43), Op::Add(48, 51), Op::Add(50, 53), Op::Add(52, 47), Op::Add(46, 49), Op::UnconstrainedU32Add3(vec![24, 25, 26, 27], vec![54, 55, 56, 57], vec![20, 21, 22, 23]), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::Sub(62, 29), Op::Sub(62, 31), Op::Mul(63, 64), Op::Mul(62, 65), Op::AssertEq(vec![66], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(38, 58), Op::U8Xor(39, 59), Op::U8Xor(36, 60), Op::U8Xor(37, 61), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![68, 69, 70, 67]), Op::U8RangeCheck(71, 72), Op::U8RangeCheck(73, 74), Op::Mul(75, 75), Op::AssertEq(vec![76], vec![75], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(54, 71), Op::U8XorSplit7(55, 72), Op::U8XorSplit7(56, 73), Op::U8XorSplit7(57, 74), Op::Add(77, 80), Op::Add(79, 82), Op::Add(81, 84), Op::Add(83, 78)], ctrl: Ctrl::Return(0, vec![58, 59, 60, 61, 85, 86, 87, 88, 71, 72, 73, 74, 68, 69, 70, 67]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 47, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_84() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![16, 17, 18, 19], vec![64, 65, 66, 67]), Op::U8RangeCheck(128, 129), Op::U8RangeCheck(130, 131), Op::Const(G::from_u64(1)), Op::Sub(132, 133), Op::Const(G::from_u64(2)), Op::Sub(132, 135), Op::Mul(134, 136), Op::Mul(132, 137), Op::Const(G::from_u64(0)), Op::AssertEq(vec![138], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(48, 128), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::UnconstrainedU32Add(vec![32, 33, 34, 35], vec![142, 143, 140, 141]), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::Mul(148, 148), Op::AssertEq(vec![149], vec![148], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(16, 144), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::Add(152, 155), Op::Add(154, 157), Op::Add(156, 151), Op::Add(150, 153), Op::UnconstrainedU32Add3(vec![128, 129, 130, 131], vec![158, 159, 160, 161], vec![68, 69, 70, 71]), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::Sub(166, 133), Op::Sub(166, 135), Op::Mul(167, 168), Op::Mul(166, 169), Op::AssertEq(vec![170], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(142, 162), Op::U8Xor(143, 163), Op::U8Xor(140, 164), Op::U8Xor(141, 165), Op::UnconstrainedU32Add(vec![144, 145, 146, 147], vec![172, 173, 174, 171]), Op::U8RangeCheck(175, 176), Op::U8RangeCheck(177, 178), Op::Mul(179, 179), Op::AssertEq(vec![180], vec![179], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(158, 175), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::Add(181, 184), Op::Add(183, 186), Op::Add(185, 188), Op::Add(187, 182), Op::UnconstrainedU32Add3(vec![4, 5, 6, 7], vec![20, 21, 22, 23], vec![72, 73, 74, 75]), Op::U8RangeCheck(193, 194), Op::U8RangeCheck(195, 196), Op::Sub(197, 133), Op::Sub(197, 135), Op::Mul(198, 199), Op::Mul(197, 200), Op::AssertEq(vec![201], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(52, 193), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::UnconstrainedU32Add(vec![36, 37, 38, 39], vec![204, 205, 202, 203]), Op::U8RangeCheck(206, 207), Op::U8RangeCheck(208, 209), Op::Mul(210, 210), Op::AssertEq(vec![211], vec![210], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(20, 206), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::Add(214, 217), Op::Add(216, 219), Op::Add(218, 213), Op::Add(212, 215), Op::UnconstrainedU32Add3(vec![193, 194, 195, 196], vec![220, 221, 222, 223], vec![76, 77, 78, 79]), Op::U8RangeCheck(224, 225), Op::U8RangeCheck(226, 227), Op::Sub(228, 133), Op::Sub(228, 135), Op::Mul(229, 230), Op::Mul(228, 231), Op::AssertEq(vec![232], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(204, 224), Op::U8Xor(205, 225), Op::U8Xor(202, 226), Op::U8Xor(203, 227), Op::UnconstrainedU32Add(vec![206, 207, 208, 209], vec![234, 235, 236, 233]), Op::U8RangeCheck(237, 238), Op::U8RangeCheck(239, 240), Op::Mul(241, 241), Op::AssertEq(vec![242], vec![241], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(220, 237), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::Add(243, 246), Op::Add(245, 248), Op::Add(247, 250), Op::Add(249, 244), Op::UnconstrainedU32Add3(vec![8, 9, 10, 11], vec![24, 25, 26, 27], vec![80, 81, 82, 83]), Op::U8RangeCheck(255, 256), Op::U8RangeCheck(257, 258), Op::Sub(259, 133), Op::Sub(259, 135), Op::Mul(260, 261), Op::Mul(259, 262), Op::AssertEq(vec![263], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(56, 255), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![266, 267, 264, 265]), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::Mul(272, 272), Op::AssertEq(vec![273], vec![272], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(24, 268), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::Add(276, 279), Op::Add(278, 281), Op::Add(280, 275), Op::Add(274, 277), Op::UnconstrainedU32Add3(vec![255, 256, 257, 258], vec![282, 283, 284, 285], vec![84, 85, 86, 87]), Op::U8RangeCheck(286, 287), Op::U8RangeCheck(288, 289), Op::Sub(290, 133), Op::Sub(290, 135), Op::Mul(291, 292), Op::Mul(290, 293), Op::AssertEq(vec![294], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(266, 286), Op::U8Xor(267, 287), Op::U8Xor(264, 288), Op::U8Xor(265, 289), Op::UnconstrainedU32Add(vec![268, 269, 270, 271], vec![296, 297, 298, 295]), Op::U8RangeCheck(299, 300), Op::U8RangeCheck(301, 302), Op::Mul(303, 303), Op::AssertEq(vec![304], vec![303], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(282, 299), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::Add(305, 308), Op::Add(307, 310), Op::Add(309, 312), Op::Add(311, 306), Op::UnconstrainedU32Add3(vec![12, 13, 14, 15], vec![28, 29, 30, 31], vec![88, 89, 90, 91]), Op::U8RangeCheck(317, 318), Op::U8RangeCheck(319, 320), Op::Sub(321, 133), Op::Sub(321, 135), Op::Mul(322, 323), Op::Mul(321, 324), Op::AssertEq(vec![325], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(60, 317), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::UnconstrainedU32Add(vec![44, 45, 46, 47], vec![328, 329, 326, 327]), Op::U8RangeCheck(330, 331), Op::U8RangeCheck(332, 333), Op::Mul(334, 334), Op::AssertEq(vec![335], vec![334], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(28, 330), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::Add(338, 341), Op::Add(340, 343), Op::Add(342, 337), Op::Add(336, 339), Op::UnconstrainedU32Add3(vec![317, 318, 319, 320], vec![344, 345, 346, 347], vec![92, 93, 94, 95]), Op::U8RangeCheck(348, 349), Op::U8RangeCheck(350, 351), Op::Sub(352, 133), Op::Sub(352, 135), Op::Mul(353, 354), Op::Mul(352, 355), Op::AssertEq(vec![356], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(328, 348), Op::U8Xor(329, 349), Op::U8Xor(326, 350), Op::U8Xor(327, 351), Op::UnconstrainedU32Add(vec![330, 331, 332, 333], vec![358, 359, 360, 357]), Op::U8RangeCheck(361, 362), Op::U8RangeCheck(363, 364), Op::Mul(365, 365), Op::AssertEq(vec![366], vec![365], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(344, 361), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::Add(367, 370), Op::Add(369, 372), Op::Add(371, 374), Op::Add(373, 368), Op::UnconstrainedU32Add3(vec![162, 163, 164, 165], vec![251, 252, 253, 254], vec![96, 97, 98, 99]), Op::U8RangeCheck(379, 380), Op::U8RangeCheck(381, 382), Op::Sub(383, 133), Op::Sub(383, 135), Op::Mul(384, 385), Op::Mul(383, 386), Op::AssertEq(vec![387], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(358, 379), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(357, 382), Op::UnconstrainedU32Add(vec![299, 300, 301, 302], vec![390, 391, 388, 389]), Op::U8RangeCheck(392, 393), Op::U8RangeCheck(394, 395), Op::Mul(396, 396), Op::AssertEq(vec![397], vec![396], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(251, 392), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::Add(400, 403), Op::Add(402, 405), Op::Add(404, 399), Op::Add(398, 401), Op::UnconstrainedU32Add3(vec![379, 380, 381, 382], vec![406, 407, 408, 409], vec![100, 101, 102, 103]), Op::U8RangeCheck(410, 411), Op::U8RangeCheck(412, 413), Op::Sub(414, 133), Op::Sub(414, 135), Op::Mul(415, 416), Op::Mul(414, 417), Op::AssertEq(vec![418], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(390, 410), Op::U8Xor(391, 411), Op::U8Xor(388, 412), Op::U8Xor(389, 413), Op::UnconstrainedU32Add(vec![392, 393, 394, 395], vec![420, 421, 422, 419]), Op::U8RangeCheck(423, 424), Op::U8RangeCheck(425, 426), Op::Mul(427, 427), Op::AssertEq(vec![428], vec![427], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(406, 423), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::Add(429, 432), Op::Add(431, 434), Op::Add(433, 436), Op::Add(435, 430), Op::UnconstrainedU32Add3(vec![224, 225, 226, 227], vec![313, 314, 315, 316], vec![104, 105, 106, 107]), Op::U8RangeCheck(441, 442), Op::U8RangeCheck(443, 444), Op::Sub(445, 133), Op::Sub(445, 135), Op::Mul(446, 447), Op::Mul(445, 448), Op::AssertEq(vec![449], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(172, 441), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(171, 444), Op::UnconstrainedU32Add(vec![361, 362, 363, 364], vec![452, 453, 450, 451]), Op::U8RangeCheck(454, 455), Op::U8RangeCheck(456, 457), Op::Mul(458, 458), Op::AssertEq(vec![459], vec![458], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(313, 454), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::Add(462, 465), Op::Add(464, 467), Op::Add(466, 461), Op::Add(460, 463), Op::UnconstrainedU32Add3(vec![441, 442, 443, 444], vec![468, 469, 470, 471], vec![108, 109, 110, 111]), Op::U8RangeCheck(472, 473), Op::U8RangeCheck(474, 475), Op::Sub(476, 133), Op::Sub(476, 135), Op::Mul(477, 478), Op::Mul(476, 479), Op::AssertEq(vec![480], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(452, 472), Op::U8Xor(453, 473), Op::U8Xor(450, 474), Op::U8Xor(451, 475), Op::UnconstrainedU32Add(vec![454, 455, 456, 457], vec![482, 483, 484, 481]), Op::U8RangeCheck(485, 486), Op::U8RangeCheck(487, 488), Op::Mul(489, 489), Op::AssertEq(vec![490], vec![489], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(468, 485), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::Add(491, 494), Op::Add(493, 496), Op::Add(495, 498), Op::Add(497, 492), Op::UnconstrainedU32Add3(vec![286, 287, 288, 289], vec![375, 376, 377, 378], vec![112, 113, 114, 115]), Op::U8RangeCheck(503, 504), Op::U8RangeCheck(505, 506), Op::Sub(507, 133), Op::Sub(507, 135), Op::Mul(508, 509), Op::Mul(507, 510), Op::AssertEq(vec![511], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(234, 503), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(233, 506), Op::UnconstrainedU32Add(vec![175, 176, 177, 178], vec![514, 515, 512, 513]), Op::U8RangeCheck(516, 517), Op::U8RangeCheck(518, 519), Op::Mul(520, 520), Op::AssertEq(vec![521], vec![520], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(375, 516), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::Add(524, 527), Op::Add(526, 529), Op::Add(528, 523), Op::Add(522, 525), Op::UnconstrainedU32Add3(vec![503, 504, 505, 506], vec![530, 531, 532, 533], vec![116, 117, 118, 119]), Op::U8RangeCheck(534, 535), Op::U8RangeCheck(536, 537), Op::Sub(538, 133), Op::Sub(538, 135), Op::Mul(539, 540), Op::Mul(538, 541), Op::AssertEq(vec![542], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(514, 534), Op::U8Xor(515, 535), Op::U8Xor(512, 536), Op::U8Xor(513, 537), Op::UnconstrainedU32Add(vec![516, 517, 518, 519], vec![544, 545, 546, 543]), Op::U8RangeCheck(547, 548), Op::U8RangeCheck(549, 550), Op::Mul(551, 551), Op::AssertEq(vec![552], vec![551], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(530, 547), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::Add(553, 556), Op::Add(555, 558), Op::Add(557, 560), Op::Add(559, 554), Op::UnconstrainedU32Add3(vec![348, 349, 350, 351], vec![189, 190, 191, 192], vec![120, 121, 122, 123]), Op::U8RangeCheck(565, 566), Op::U8RangeCheck(567, 568), Op::Sub(569, 133), Op::Sub(569, 135), Op::Mul(570, 571), Op::Mul(569, 572), Op::AssertEq(vec![573], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(296, 565), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(295, 568), Op::UnconstrainedU32Add(vec![237, 238, 239, 240], vec![576, 577, 574, 575]), Op::U8RangeCheck(578, 579), Op::U8RangeCheck(580, 581), Op::Mul(582, 582), Op::AssertEq(vec![583], vec![582], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(189, 578), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::Add(586, 589), Op::Add(588, 591), Op::Add(590, 585), Op::Add(584, 587), Op::UnconstrainedU32Add3(vec![565, 566, 567, 568], vec![592, 593, 594, 595], vec![124, 125, 126, 127]), Op::U8RangeCheck(596, 597), Op::U8RangeCheck(598, 599), Op::Sub(600, 133), Op::Sub(600, 135), Op::Mul(601, 602), Op::Mul(600, 603), Op::AssertEq(vec![604], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(576, 596), Op::U8Xor(577, 597), Op::U8Xor(574, 598), Op::U8Xor(575, 599), Op::UnconstrainedU32Add(vec![578, 579, 580, 581], vec![606, 607, 608, 605]), Op::U8RangeCheck(609, 610), Op::U8RangeCheck(611, 612), Op::Mul(613, 613), Op::AssertEq(vec![614], vec![613], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(592, 609), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::Add(615, 618), Op::Add(617, 620), Op::Add(619, 622), Op::Add(621, 616)], ctrl: Ctrl::Return(0, vec![410, 411, 412, 413, 472, 473, 474, 475, 534, 535, 536, 537, 596, 597, 598, 599, 623, 624, 625, 626, 437, 438, 439, 440, 499, 500, 501, 502, 561, 562, 563, 564, 547, 548, 549, 550, 609, 610, 611, 612, 423, 424, 425, 426, 485, 486, 487, 488, 482, 483, 484, 481, 544, 545, 546, 543, 606, 607, 608, 605, 420, 421, 422, 419, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]) }, layout: FunctionLayout { input_size: 128, selectors: 1, auxiliaries: 369, lookups: 193 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_85() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![121, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 106, 107, 108, 109, 110, 111, 106, 112, 113, 114, 115, 116, 117, 118, 119, 120, 96, 97, 98, 99, 100, 101, 102, 103, 104, 121, 121, 121, 105, 121, 121, 121, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], 32, false)], ctrl: Ctrl::Return(0, vec![122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153]) }, layout: FunctionLayout { input_size: 106, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_86() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(86, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_87() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_88() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_89() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6)], ctrl: Ctrl::Return(0, vec![7, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_90() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7, 1, 3, 8, 8, 8, 8, 8, 8, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_91() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Call(87, vec![4], 2, false), Op::Call(87, vec![6], 2, false), Op::Const(G::from_u64(256)), Op::Mul(9, 3), Op::Const(G::from_u64(65536)), Op::Mul(11, 5), Op::Const(G::from_u64(16777216)), Op::Mul(13, 7), Op::Add(12, 14), Op::Add(10, 15), Op::Add(1, 16), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17, 1, 3, 5, 7, 18, 18, 18, 18, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_92() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Call(87, vec![2], 2, false), Op::Call(87, vec![4], 2, false), Op::Call(87, vec![6], 2, false), Op::Call(87, vec![8], 2, false), Op::Call(87, vec![10], 2, false), Op::Call(87, vec![12], 2, false), Op::Call(87, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_93() -> Function { + Function { body: Block { ops: vec![Op::Call(92, vec![0], 9, false), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Const(G::from_u64(65536)), Op::Mul(12, 3), Op::Const(G::from_u64(16777216)), Op::Mul(14, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 8), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(1, 29)], ctrl: Ctrl::Return(0, vec![30, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_94() -> Function { + Function { body: Block { ops: vec![Op::Call(92, vec![0], 9, false), Op::Call(92, vec![9], 9, false), Op::Call(92, vec![18], 9, false), Op::Call(92, vec![27], 9, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_95() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(92, vec![0], 9, false), Op::Call(92, vec![10], 9, false), Op::Call(92, vec![19], 9, false), Op::Call(92, vec![28], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(95, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_96() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3, 3, 3, 3])], ctrl: Ctrl::Return(0, vec![4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(88, vec![0], 2, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(93, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(2, vec![13, 11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(88, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 13, 5, 12, 12, 10])], ctrl: Ctrl::Return(3, vec![14, 11]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(96, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(4, vec![12, 9]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(96, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(5, vec![12, 9]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(96, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(5)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(6, vec![12, 9]) }), (G::from_u64(6), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(89, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(96, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(6)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(7, vec![18, 15]) }), (G::from_u64(7), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(89, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(96, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(7)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(8, vec![18, 15]) }), (G::from_u64(8), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(89, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(96, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(9, vec![18, 15]) }), (G::from_u64(9), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 8), Op::Add(2, 8), Op::Call(96, vec![6, 9, 10], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(9)), Op::Store(vec![13, 14, 5, 13, 13, 11])], ctrl: Ctrl::Return(10, vec![15, 12]) }), (G::from_u64(10), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 12, 5, 10])], ctrl: Ctrl::Return(11, vec![13, 11]) }), (G::from_u64(11), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 7, 5, 10])], ctrl: Ctrl::Return(12, vec![13, 11]) }), (G::from_u64(12), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 12, 5, 10])], ctrl: Ctrl::Return(13, vec![13, 11]) }), (G::from_u64(13), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 7, 5, 10])], ctrl: Ctrl::Return(14, vec![13, 11]) }), (G::from_u64(14), Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 12, 5, 10])], ctrl: Ctrl::Return(15, vec![14, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(96, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 7, 5, 10])], ctrl: Ctrl::Return(16, vec![14, 11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_97() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(97, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_98() -> Function { + Function { body: Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Call(89, vec![2], 2, false), Op::Call(97, vec![4, 3], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_99() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Call(89, vec![3], 2, false), Op::Call(97, vec![5, 4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(99, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 2, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_100() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(2, 3), Op::Call(100, vec![4, 5, 2], 1, false), Op::Add(3, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(1, 3), Op::Call(100, vec![4, 5, 2], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_101() -> Function { + Function { body: Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![10], 10, false), Op::Call(91, vec![20], 10, false), Op::Call(90, vec![30], 10, false), Op::Call(88, vec![40], 2, false), Op::Call(89, vec![42], 2, false), Op::Const(G::from_u64(0)), Op::Call(96, vec![44, 43, 45], 2, false), Op::Call(89, vec![47], 2, false), Op::Call(97, vec![49, 48], 2, false), Op::Call(89, vec![51], 2, false), Op::Call(99, vec![53, 52], 2, false), Op::Call(100, vec![52, 45, 41], 1, false), Op::EqZero(56), Op::Add(56, 57), Op::Add(58, 58), Op::Add(48, 59), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(61, 62), Op::U8RangeCheck(63, 64), Op::U8RangeCheck(65, 66), Op::U8RangeCheck(67, 68), Op::Const(G::from_u64(256)), Op::Mul(69, 62), Op::Const(G::from_u64(65536)), Op::Mul(71, 63), Op::Const(G::from_u64(16777216)), Op::Mul(73, 64), Op::Const(G::from_u64(4294967296)), Op::Mul(75, 65), Op::Const(G::from_u64(1099511627776)), Op::Mul(77, 66), Op::Const(G::from_u64(281474976710656)), Op::Mul(79, 67), Op::Const(G::from_u64(72057594037927936)), Op::Mul(81, 68), Op::Add(80, 82), Op::Add(78, 83), Op::Add(76, 84), Op::Add(74, 85), Op::Add(72, 86), Op::Add(70, 87), Op::Add(61, 88), Op::AssertEq(vec![89], vec![60], None), Op::Const(G::from_u64(1020)), Op::Sub(68, 90), Op::Add(67, 91), Op::Add(66, 92), Op::Add(65, 93), Op::EqZero(94), Op::Add(63, 64), Op::Add(62, 96), Op::Add(61, 97), Op::EqZero(98), Op::Const(G::from_u64(1)), Op::Sub(100, 99), Op::Mul(95, 101), Op::Sub(100, 102), Op::AssertEq(vec![103], vec![100], None), Op::UnconstrainedGToBytes(59), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 107), Op::U8RangeCheck(108, 109), Op::U8RangeCheck(110, 111), Op::Mul(69, 105), Op::Mul(71, 106), Op::Mul(73, 107), Op::Mul(75, 108), Op::Mul(77, 109), Op::Mul(79, 110), Op::Mul(81, 111), Op::Add(117, 118), Op::Add(116, 119), Op::Add(115, 120), Op::Add(114, 121), Op::Add(113, 122), Op::Add(112, 123), Op::Add(104, 124), Op::AssertEq(vec![125], vec![59], None), Op::Sub(111, 90), Op::Add(110, 126), Op::Add(109, 127), Op::Add(108, 128), Op::EqZero(129), Op::Add(106, 107), Op::Add(105, 131), Op::Add(104, 132), Op::EqZero(133), Op::Sub(100, 134), Op::Mul(130, 135), Op::Sub(100, 136), Op::AssertEq(vec![137], vec![100], None), Op::UnconstrainedGToBytes(41), Op::U8RangeCheck(138, 139), Op::U8RangeCheck(140, 141), Op::U8RangeCheck(142, 143), Op::U8RangeCheck(144, 145), Op::Mul(69, 139), Op::Mul(71, 140), Op::Mul(73, 141), Op::Mul(75, 142), Op::Mul(77, 143), Op::Mul(79, 144), Op::Mul(81, 145), Op::Add(151, 152), Op::Add(150, 153), Op::Add(149, 154), Op::Add(148, 155), Op::Add(147, 156), Op::Add(146, 157), Op::Add(138, 158), Op::AssertEq(vec![159], vec![41], None), Op::Sub(145, 90), Op::Add(144, 160), Op::Add(143, 161), Op::Add(142, 162), Op::EqZero(163), Op::Add(140, 141), Op::Add(139, 165), Op::Add(138, 166), Op::EqZero(167), Op::Sub(100, 168), Op::Mul(164, 169), Op::Sub(100, 170), Op::AssertEq(vec![171], vec![100], None)], ctrl: Ctrl::Return(0, vec![46, 43, 50, 31, 54, 41, 1, 11, 59, 61, 62, 63, 64, 65, 66, 67, 68, 32, 33, 34, 35, 36, 37, 38, 39, 22, 23, 24, 25, 26, 27, 28, 29, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9, 104, 105, 106, 107, 108, 109, 110, 111, 138, 139, 140, 141, 142, 143, 144, 145, 55]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 97, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_102() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![57, 48, 49, 50, 51, 52, 53, 54, 55, 56]), Op::Store(vec![57, 40, 41, 42, 43, 44, 45, 46, 47, 58]), Op::Store(vec![57, 32, 33, 34, 35, 36, 37, 38, 39, 59]), Op::Store(vec![57, 24, 25, 26, 27, 28, 29, 30, 31, 60]), Op::Store(vec![57, 16, 17, 18, 19, 20, 21, 22, 23, 61]), Op::Store(vec![57, 8, 9, 10, 11, 12, 13, 14, 15, 62]), Op::Store(vec![57, 0, 1, 2, 3, 4, 5, 6, 7, 63])], ctrl: Ctrl::Return(0, vec![64]) }, layout: FunctionLayout { input_size: 57, selectors: 1, auxiliaries: 8, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_103() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![11], 10, false), Op::Call(91, vec![21], 10, false), Op::Call(90, vec![31], 10, false), Op::Call(88, vec![41], 2, false), Op::Call(89, vec![43], 2, false), Op::Const(G::from_u64(0)), Op::Call(96, vec![45, 44, 46], 2, false), Op::Call(89, vec![48], 2, false), Op::Call(97, vec![50, 49], 2, false), Op::Call(89, vec![52], 2, false), Op::Call(99, vec![54, 53], 2, false), Op::Call(100, vec![53, 46, 42], 1, false), Op::EqZero(57), Op::Add(57, 58), Op::Add(59, 59), Op::Add(49, 60), Op::UnconstrainedGToBytes(61), Op::U8RangeCheck(62, 63), Op::U8RangeCheck(64, 65), Op::U8RangeCheck(66, 67), Op::U8RangeCheck(68, 69), Op::Const(G::from_u64(256)), Op::Mul(70, 63), Op::Const(G::from_u64(65536)), Op::Mul(72, 64), Op::Const(G::from_u64(16777216)), Op::Mul(74, 65), Op::Const(G::from_u64(4294967296)), Op::Mul(76, 66), Op::Const(G::from_u64(1099511627776)), Op::Mul(78, 67), Op::Const(G::from_u64(281474976710656)), Op::Mul(80, 68), Op::Const(G::from_u64(72057594037927936)), Op::Mul(82, 69), Op::Add(81, 83), Op::Add(79, 84), Op::Add(77, 85), Op::Add(75, 86), Op::Add(73, 87), Op::Add(71, 88), Op::Add(62, 89), Op::AssertEq(vec![90], vec![61], None), Op::Const(G::from_u64(1020)), Op::Sub(69, 91), Op::Add(68, 92), Op::Add(67, 93), Op::Add(66, 94), Op::EqZero(95), Op::Add(64, 65), Op::Add(63, 97), Op::Add(62, 98), Op::EqZero(99), Op::Const(G::from_u64(1)), Op::Sub(101, 100), Op::Mul(96, 102), Op::Sub(101, 103), Op::AssertEq(vec![104], vec![101], None), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(105, 106), Op::U8RangeCheck(107, 108), Op::U8RangeCheck(109, 110), Op::U8RangeCheck(111, 112), Op::Mul(70, 106), Op::Mul(72, 107), Op::Mul(74, 108), Op::Mul(76, 109), Op::Mul(78, 110), Op::Mul(80, 111), Op::Mul(82, 112), Op::Add(118, 119), Op::Add(117, 120), Op::Add(116, 121), Op::Add(115, 122), Op::Add(114, 123), Op::Add(113, 124), Op::Add(105, 125), Op::AssertEq(vec![126], vec![60], None), Op::Sub(112, 91), Op::Add(111, 127), Op::Add(110, 128), Op::Add(109, 129), Op::EqZero(130), Op::Add(107, 108), Op::Add(106, 132), Op::Add(105, 133), Op::EqZero(134), Op::Sub(101, 135), Op::Mul(131, 136), Op::Sub(101, 137), Op::AssertEq(vec![138], vec![101], None), Op::UnconstrainedGToBytes(42), Op::U8RangeCheck(139, 140), Op::U8RangeCheck(141, 142), Op::U8RangeCheck(143, 144), Op::U8RangeCheck(145, 146), Op::Mul(70, 140), Op::Mul(72, 141), Op::Mul(74, 142), Op::Mul(76, 143), Op::Mul(78, 144), Op::Mul(80, 145), Op::Mul(82, 146), Op::Add(152, 153), Op::Add(151, 154), Op::Add(150, 155), Op::Add(149, 156), Op::Add(148, 157), Op::Add(147, 158), Op::Add(139, 159), Op::AssertEq(vec![160], vec![42], None), Op::Sub(146, 91), Op::Add(145, 161), Op::Add(144, 162), Op::Add(143, 163), Op::EqZero(164), Op::Add(141, 142), Op::Add(140, 166), Op::Add(139, 167), Op::EqZero(168), Op::Sub(101, 169), Op::Mul(165, 170), Op::Sub(101, 171), Op::AssertEq(vec![172], vec![101], None), Op::Sub(1, 101), Op::Call(103, vec![56, 173], 3, false), Op::Store(vec![46, 47, 44, 51, 32, 55, 42, 2, 12, 60, 174]), Op::Store(vec![46, 139, 140, 141, 142, 143, 144, 145, 146, 175]), Op::Store(vec![46, 105, 106, 107, 108, 109, 110, 111, 112, 178]), Op::Store(vec![46, 3, 4, 5, 6, 7, 8, 9, 10, 179]), Op::Store(vec![46, 13, 14, 15, 16, 17, 18, 19, 20, 180]), Op::Store(vec![46, 23, 24, 25, 26, 27, 28, 29, 30, 181]), Op::Store(vec![46, 33, 34, 35, 36, 37, 38, 39, 40, 182]), Op::Store(vec![46, 62, 63, 64, 65, 66, 67, 68, 69, 183])], ctrl: Ctrl::Return(1, vec![177, 184, 176]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_104() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![2], 2, false), Op::Call(95, vec![4, 3], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7, 5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_105() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(105, vec![3, 5], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(65535), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 9, 2, 6])], ctrl: Ctrl::Return(2, vec![10, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_106() -> Function { + Function { body: Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![10], 10, false), Op::Call(90, vec![20], 10, false), Op::Call(90, vec![30], 10, false), Op::Call(90, vec![40], 10, false), Op::Call(90, vec![50], 10, false), Op::Call(90, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79])], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 80, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 79, lookups: 16 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_107() -> Function { + Function { body: Block { ops: vec![Op::Call(90, vec![0], 10, false), Op::Call(90, vec![10], 10, false), Op::Call(90, vec![20], 10, false), Op::Call(90, vec![30], 10, false), Op::Call(90, vec![40], 10, false), Op::Call(90, vec![50], 10, false), Op::Call(90, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79]), Op::Call(90, vec![70], 10, false), Op::Call(103, vec![90, 81], 3, false), Op::Call(104, vec![93], 3, false), Op::Call(105, vec![96, 81], 2, false), Op::Store(vec![71, 82, 83, 84, 85, 86, 87, 88, 89, 92]), Op::Call(306, vec![80, 99], 1, false)], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 100, 91, 94, 95, 97, 98]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 99, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_108() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 4]), Op::Store(vec![5, 2, 6]), Op::Store(vec![5, 1, 7]), Op::Store(vec![5, 0, 8])], ctrl: Ctrl::Return(0, vec![9]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_109() -> Function { + Function { body: Block { ops: vec![Op::Call(108, vec![28, 29, 30, 31, 32], 1, false), Op::Call(108, vec![24, 25, 26, 27, 33], 1, false), Op::Call(108, vec![20, 21, 22, 23, 34], 1, false), Op::Call(108, vec![16, 17, 18, 19, 35], 1, false), Op::Call(108, vec![12, 13, 14, 15, 36], 1, false), Op::Call(108, vec![8, 9, 10, 11, 37], 1, false), Op::Call(108, vec![4, 5, 6, 7, 38], 1, false), Op::Call(108, vec![0, 1, 2, 3, 39], 1, false)], ctrl: Ctrl::Return(0, vec![40]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_110() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_111() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(11)), Op::Call(86, vec![97, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 97, 97, 97, 97, 97, 97, 97, 97, 98, 97, 97, 97, 99, 97, 97, 97, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96], 32, false), Op::Store(vec![100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131])], ctrl: Ctrl::Return(0, vec![132]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 98, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_112() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(111, vec![1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(111, vec![2, 1], 1, false)], ctrl: Ctrl::Return(1, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_113() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1), Op::EqZero(5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(113, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_114() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Sub(7, 2), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(114, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(114, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(114, vec![5, 8, 2], 1, false), Op::Store(vec![21, 4, 22])], ctrl: Ctrl::Return(3, vec![23]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_115() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(2, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(115, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(115, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(115, vec![5, 8, 2], 1, false), Op::Store(vec![20, 4, 21])], ctrl: Ctrl::Return(3, vec![22]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 27, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_116() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(12, 4), Op::Const(G::from_u64(65536)), Op::Mul(14, 5), Op::Const(G::from_u64(16777216)), Op::Mul(16, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 10), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(3, 31), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(33, 34), Op::U8RangeCheck(35, 36), Op::U8RangeCheck(37, 38), Op::U8RangeCheck(39, 40), Op::Mul(12, 34), Op::Mul(14, 35), Op::Mul(16, 36), Op::Mul(18, 37), Op::Mul(20, 38), Op::Mul(22, 39), Op::Mul(24, 40), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(33, 53), Op::AssertEq(vec![54], vec![32], None), Op::Const(G::from_u64(1020)), Op::Sub(40, 55), Op::Add(39, 56), Op::Add(38, 57), Op::Add(37, 58), Op::EqZero(59), Op::Add(35, 36), Op::Add(34, 61), Op::Add(33, 62), Op::EqZero(63), Op::Const(G::from_u64(1)), Op::Sub(65, 64), Op::Mul(60, 66), Op::Sub(65, 67), Op::AssertEq(vec![68], vec![65], None)], ctrl: Ctrl::Return(0, vec![33, 34, 35, 36, 37, 38, 39, 40, 11, 1, 65]) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![15, 15, 15, 15, 15, 15, 15, 15, 0, 1, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(116, vec![13, 14], 11, false)], ctrl: Ctrl::Return(2, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_117() -> Function { + Function { body: Block { ops: vec![Op::Call(116, vec![0, 1], 11, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(86, vec![57, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, 70, 71, 72, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 58, 59, 60, 61, 62, 63, 64, 65, 57, 57, 57, 57, 66, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57], 32, false), Op::Store(vec![57, 5, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113])], ctrl: Ctrl::Return(0, vec![114]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(116, vec![14, 15], 11, false), Op::Call(116, vec![25, 26], 11, false), Op::Call(116, vec![36, 37], 11, false), Op::Call(116, vec![47, 48], 11, false), Op::Call(116, vec![58, 59], 11, false), Op::Call(116, vec![69, 70], 11, false), Op::Call(116, vec![80, 81], 11, false), Op::Const(G::from_u64(8)), Op::Add(82, 93), Op::Add(71, 95), Op::Add(60, 96), Op::Add(49, 97), Op::Add(38, 98), Op::Add(27, 99), Op::Add(16, 100), Op::Mul(94, 101), Op::Load(10, 91)], ctrl: Ctrl::MatchContinue(103, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(9, vec![116]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![116]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(11, vec![113]) })), 1, 4, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(15)), Op::Sub(2, 114), Op::EqZero(115), Op::EqZero(2), Op::Mul(113, 116), Op::Sub(116, 118), Op::Add(113, 119), Op::Load(8, 3), Op::Call(4, vec![121, 122, 123, 124, 125, 126, 127, 128], 1, false), Op::Mul(113, 129), Op::Const(G::from_u64(2)), Op::Mul(131, 120), Op::Const(G::from_u64(8)), Op::Mul(133, 130), Op::Add(132, 134), Op::Add(117, 135), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(86, vec![184, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 169, 175, 176, 177, 178, 179, 180, 181, 182, 183, 121, 122, 123, 124, 125, 126, 127, 128, 102, 184, 184, 184, 136, 184, 184, 184, 6, 7, 8, 9, 10, 11, 12, 13, 17, 18, 19, 20, 21, 22, 23, 24, 28, 29, 30, 31, 32, 33, 34, 35, 39, 40, 41, 42, 43, 44, 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 61, 62, 63, 64, 65, 66, 67, 68, 72, 73, 74, 75, 76, 77, 78, 79, 83, 84, 85, 86, 87, 88, 89, 90], 32, false)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![217, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216])], ctrl: Ctrl::Return(12, vec![218]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(116, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Call(13, vec![249, 250, 251, 252, 253, 254, 255, 256], 8, false), Op::Store(vec![257, 258, 259, 260, 261, 262, 263, 264]), Op::Store(vec![217, 218, 219, 220, 221, 222, 217, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247]), Op::Store(vec![248, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(117, vec![91, 92, 248, 265, 266, 267], 1, false)], ctrl: Ctrl::Return(13, vec![268]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 217), Op::Store(vec![185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(117, vec![91, 92, 218, 3, 219, 5], 1, false)], ctrl: Ctrl::Return(14, vec![220]) }))) }))) })) }))) }, layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_118() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(117, vec![33, 0, 34, 35, 36, 37], 1, false), Op::Call(77, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_119() -> Function { + Function { body: Block { ops: vec![Op::Call(114, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Const(G::from_u64(0)), Op::Store(vec![37, 37, 37, 37, 37, 37, 37, 37]), Op::Store(vec![4, 5, 6, 7, 8, 9, 4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Call(117, vec![36, 3, 37, 38, 39, 40], 1, false), Op::Call(77, vec![41], 32, false), Op::Store(vec![42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73])], ctrl: Ctrl::Return(0, vec![74]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 40, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_120() -> Function { + Function { body: Block { ops: vec![Op::Call(113, vec![1, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(119, vec![0, 1, 2], 1, false), Op::Call(111, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_121() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(121, vec![3], 1, false), Op::Mul(4, 5), Op::Add(2, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_122() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(0, vec![3, 9], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(122, vec![7, 1], 1, false), Op::Store(vec![15, 3, 4, 5, 6, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 9), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::AssertEq(vec![6], vec![12], None), Op::AssertEq(vec![5], vec![11], None), Op::Const(G::from_u64(0)), Op::Call(122, vec![7, 13], 1, false), Op::Store(vec![17, 3, 4, 5, 6, 18])], ctrl: Ctrl::Return(3, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(122, vec![0, 13], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 18])], ctrl: Ctrl::Return(4, vec![19]) }))) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_123() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14, 14, 14, 14]), Op::Store(vec![13, 2, 3, 4, 5, 15])], ctrl: Ctrl::Return(1, vec![16, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(123, vec![12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 13]), Op::Store(vec![15, 8, 9, 10, 11, 14])], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_124() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(123, vec![0], 2, false), Op::Call(124, vec![13], 1, false), Op::Call(124, vec![14], 1, false), Op::Call(122, vec![15, 16], 1, false)], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_125() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(296, vec![1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], None), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(119, vec![8, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(121, vec![5], 1, false), Op::Call(125, vec![6, 9, 2, 3], 1, false), Op::Store(vec![11, 12, 5, 8, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_126() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(121, vec![12], 1, false), Op::Load(6, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(121, vec![22], 1, false), Op::Sub(13, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Call(115, vec![7, 2, 3], 1, false), Op::Call(115, vec![17, 2, 3], 1, false), Op::AssertEq(vec![26], vec![27], None), Op::Call(111, vec![8, 18], 1, false), Op::Call(120, vec![7, 2, 3, 28], 1, false), Op::Call(126, vec![19, 1, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![32, 13, 12, 7, 29, 30])], ctrl: Ctrl::Return(1, vec![33, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Call(112, vec![11, 8, 27], 1, false), Op::Call(120, vec![7, 2, 3, 29], 1, false), Op::Call(126, vec![9, 28, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![33, 13, 12, 7, 30, 31])], ctrl: Ctrl::Return(2, vec![34, 32]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(112, vec![11, 8, 21], 1, false), Op::Call(120, vec![7, 2, 3, 23], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26, 26, 26, 26]), Op::Store(vec![25, 13, 12, 7, 24, 27])], ctrl: Ctrl::Return(3, vec![28, 22]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 32, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_127() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 4), Op::Call(126, vec![0, 1, 2, 5], 2, false), Op::Call(127, vec![6, 7, 2, 5], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_128() -> Function { + Function { body: Block { ops: vec![Op::Call(296, vec![1], 1, false), Op::Call(296, vec![3], 1, false), Op::Sub(6, 7), Op::EqZero(8), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], None), Op::Call(125, vec![3, 1, 2, 5], 1, false), Op::Call(124, vec![11], 1, false), Op::Call(127, vec![12, 4, 2, 5], 2, false), Op::Call(296, vec![14], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], None), Op::Load(6, 13)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(299, vec![22], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![0, 18], 1, false), Op::Sub(25, 21), Op::EqZero(26)], ctrl: Ctrl::Return(0, vec![27]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 20, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_129() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(129, vec![4, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_130() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(0, 0), Op::Call(130, vec![5, 4], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 6)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_131() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 8), Op::Call(186, vec![9], 1, false), Op::Store(vec![8, 8, 8]), Op::Call(129, vec![0, 11], 1, false), Op::Call(130, vec![10, 12], 1, false), Op::Add(13, 13), Op::Add(4, 6), Op::Add(5, 7), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Mul(17, 17), Op::Const(G::from_u64(7)), Op::Mul(18, 18), Op::Mul(20, 21), Op::Sub(19, 22), Op::UnconstrainedGInverse(23), Op::Mul(23, 24), Op::Sub(25, 8), Op::Mul(23, 26), Op::AssertEq(vec![27], vec![18], None), Op::Mul(24, 26), Op::AssertEq(vec![28], vec![18], None), Op::Mul(17, 24), Op::Sub(18, 18), Op::Mul(30, 24), Op::Mul(15, 29), Op::Mul(16, 31), Op::Mul(20, 33), Op::Add(32, 34), Op::Mul(15, 31), Op::Mul(16, 29), Op::Add(36, 37), Op::Sub(4, 6), Op::Sub(5, 7), Op::Mul(14, 14), Op::Sub(41, 22), Op::UnconstrainedGInverse(42), Op::Mul(42, 43), Op::Sub(44, 8), Op::Mul(42, 45), Op::AssertEq(vec![46], vec![18], None), Op::Mul(43, 45), Op::AssertEq(vec![47], vec![18], None), Op::Mul(14, 43), Op::Mul(30, 43), Op::Mul(39, 48), Op::Mul(40, 49), Op::Mul(20, 51), Op::Add(50, 52), Op::Mul(39, 49), Op::Mul(40, 48), Op::Add(54, 55), Op::Mul(2, 53), Op::Mul(3, 56), Op::Mul(20, 58), Op::Add(57, 59), Op::Mul(2, 56), Op::Mul(3, 53), Op::Add(61, 62), Op::Add(35, 60), Op::Add(38, 63)], ctrl: Ctrl::Return(0, vec![64, 65]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 25, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_132() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(186, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(129, vec![0, 5], 1, false), Op::Call(130, vec![3, 6], 1, false), Op::Mul(2, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_133() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(22, 10), Op::Const(G::from_u64(65536)), Op::Mul(24, 11), Op::Const(G::from_u64(16777216)), Op::Mul(26, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(28, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(30, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(32, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(34, 16), Op::Add(33, 35), Op::Add(31, 36), Op::Add(29, 37), Op::Add(27, 38), Op::Add(25, 39), Op::Add(23, 40), Op::Add(9, 41), Op::Const(G::from_u64(0)), Op::Sub(19, 42), Op::Sub(20, 43), Op::Mul(6, 44), Op::Const(G::from_u64(7)), Op::Mul(7, 45), Op::Mul(47, 48), Op::Add(46, 49), Op::Mul(6, 45), Op::Mul(7, 44), Op::Add(51, 52), Op::Add(4, 50), Op::Add(5, 53), Op::Mul(6, 2), Op::Mul(7, 3), Op::Mul(47, 57), Op::Add(56, 58), Op::Mul(6, 3), Op::Mul(7, 2), Op::Add(60, 61), Op::Call(133, vec![17, 21, 2, 3, 54, 55, 59, 62], 4, false)], ctrl: Ctrl::Return(1, vec![63, 64, 65, 66]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_134() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::U8RangeCheck(12, 13), Op::Const(G::from_u64(256)), Op::Mul(14, 7), Op::Const(G::from_u64(65536)), Op::Mul(16, 8), Op::Const(G::from_u64(16777216)), Op::Mul(18, 9), Op::Const(G::from_u64(4294967296)), Op::Mul(20, 10), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 11), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 12), Op::Const(G::from_u64(72057594037927936)), Op::Mul(26, 13), Op::Add(25, 27), Op::Add(23, 28), Op::Add(21, 29), Op::Add(19, 30), Op::Add(17, 31), Op::Add(15, 32), Op::Add(6, 33), Op::AssertEq(vec![34], vec![3], None), Op::Const(G::from_u64(1020)), Op::Sub(13, 35), Op::Add(12, 36), Op::Add(11, 37), Op::Add(10, 38), Op::EqZero(39), Op::Add(8, 9), Op::Add(7, 41), Op::Add(6, 42), Op::EqZero(43), Op::Const(G::from_u64(1)), Op::Sub(45, 44), Op::Mul(40, 46), Op::Sub(45, 47), Op::AssertEq(vec![48], vec![45], None), Op::UnconstrainedGToBytes(4), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::U8RangeCheck(55, 56), Op::Mul(14, 50), Op::Mul(16, 51), Op::Mul(18, 52), Op::Mul(20, 53), Op::Mul(22, 54), Op::Mul(24, 55), Op::Mul(26, 56), Op::Add(62, 63), Op::Add(61, 64), Op::Add(60, 65), Op::Add(59, 66), Op::Add(58, 67), Op::Add(57, 68), Op::Add(49, 69), Op::AssertEq(vec![70], vec![4], None), Op::Sub(56, 35), Op::Add(55, 71), Op::Add(54, 72), Op::Add(53, 73), Op::EqZero(74), Op::Add(51, 52), Op::Add(50, 76), Op::Add(49, 77), Op::EqZero(78), Op::Sub(45, 79), Op::Mul(75, 80), Op::Sub(45, 81), Op::AssertEq(vec![82], vec![45], None), Op::Call(134, vec![5, 1], 1, false), Op::Call(171, vec![49, 50, 51, 52, 53, 54, 55, 56, 83], 1, false), Op::Call(171, vec![6, 7, 8, 9, 10, 11, 12, 13, 84], 1, false)], ctrl: Ctrl::Return(1, vec![85]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 34, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_135() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(135, vec![4, 1], 1, false), Op::Call(134, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_136() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(136, vec![4, 1], 1, false), Op::Call(135, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_137() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(136, vec![1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_138() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(180, vec![0, 5, 6, 6, 6, 6, 6, 6, 6], 1, false), Op::Call(138, vec![7, 4], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_139() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![0, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Call(179, vec![10, 12, 9], 3, false), Op::Call(121, vec![13], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![14, 15]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_140() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(181, vec![0, 5], 1, false), Op::Call(139, vec![17, 8, 9, 10, 11, 12, 13, 14, 15, 3], 2, false), Op::Call(177, vec![18, 19], 18, false), Op::Call(140, vec![36, 6, 16, 3], 2, false), Op::Const(G::from_u64(256)), Op::Mul(40, 21), Op::Const(G::from_u64(65536)), Op::Mul(42, 22), Op::Const(G::from_u64(16777216)), Op::Mul(44, 23), Op::Const(G::from_u64(4294967296)), Op::Mul(46, 24), Op::Const(G::from_u64(1099511627776)), Op::Mul(48, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(50, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(52, 27), Op::Add(51, 53), Op::Add(49, 54), Op::Add(47, 55), Op::Add(45, 56), Op::Add(43, 57), Op::Add(41, 58), Op::Add(20, 59), Op::Const(G::from_u64(0)), Op::Mul(40, 29), Op::Mul(42, 30), Op::Mul(44, 31), Op::Mul(46, 32), Op::Mul(48, 33), Op::Mul(50, 34), Op::Mul(52, 35), Op::Add(67, 68), Op::Add(66, 69), Op::Add(65, 70), Op::Add(64, 71), Op::Add(63, 72), Op::Add(62, 73), Op::Add(28, 74), Op::Store(vec![61, 60, 75, 38])], ctrl: Ctrl::Return(1, vec![76, 39]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 38, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_141() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![0, 3], 1, false), Op::Sub(1, 4), Op::Add(5, 6), Op::EqZero(7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 9), Op::Add(3, 9), Op::Call(141, vec![0, 1, 10, 11, 4], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_142() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(141, vec![0, 1, 2, 4, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 6), Op::Call(142, vec![0, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(142, vec![0, 1, 2, 8], 1, false), Op::Store(vec![6, 3, 7, 6, 6, 6, 9])], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_143() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(9, 1), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(133, vec![2, 3, 6, 7, 17, 17, 10, 11], 4, false), Op::Mul(4, 18), Op::Const(G::from_u64(7)), Op::Mul(5, 19), Op::Mul(23, 24), Op::Add(22, 25), Op::Mul(4, 19), Op::Mul(5, 18), Op::Add(27, 28), Op::Add(12, 26), Op::Add(13, 29), Op::Store(vec![17, 9, 20, 21, 30, 31, 14])], ctrl: Ctrl::Return(1, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(143, vec![14, 1, 2, 3, 4, 5, 6, 7], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 13, 18])], ctrl: Ctrl::Return(2, vec![19]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_144() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 1), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(6, 11), Op::EqZero(12), Op::Sub(7, 11), Op::EqZero(14), Op::Mul(13, 15), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(144, vec![8, 1], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_145() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_146() -> Function { + Function { body: Block { ops: vec![Op::Call(301, vec![6], 1, false), Op::Call(297, vec![7], 1, false), Op::Sub(10, 11), Op::EqZero(12), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], None), Op::Sub(3, 1), Op::Call(308, vec![2, 15], 1, false), Op::Const(G::from_u64(7)), Op::Call(186, vec![1], 1, false), Op::Store(vec![14, 14, 14]), Op::Call(129, vec![16, 19], 1, false), Op::Call(130, vec![18, 20], 1, false), Op::Mul(17, 21), Op::Const(G::from_u64(0)), Op::Sub(4, 22), Op::Sub(5, 23), Op::Mul(24, 24), Op::Mul(25, 25), Op::Mul(17, 27), Op::Sub(26, 28), Op::UnconstrainedGInverse(29), Op::Mul(29, 30), Op::Sub(31, 14), Op::Mul(29, 32), Op::AssertEq(vec![33], vec![23], None), Op::Mul(30, 32), Op::AssertEq(vec![34], vec![23], None), Op::Mul(24, 30), Op::Sub(23, 25), Op::Mul(36, 30), Op::Call(143, vec![0, 1, 6, 7, 35, 37, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![38]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_147() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![8, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(294, vec![8, 13], 1, false), Op::Call(186, vec![4], 1, false), Op::Mul(5, 15), Op::Const(G::from_u64(7)), Op::Mul(6, 11), Op::Mul(17, 18), Op::Add(16, 19), Op::Mul(5, 11), Op::Mul(6, 15), Op::Add(21, 22), Op::Call(146, vec![0, 3, 1, 2, 5, 6, 7, 12, 9, 10], 1, false), Op::Call(146, vec![24, 3, 1, 2, 20, 23, 7, 14, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![25]) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_148() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(294, vec![9, 4], 1, false), Op::Call(294, vec![10, 4], 1, false), Op::Call(147, vec![0, 1, 2, 14, 13, 7, 8, 15, 16, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 18), Op::Sub(5, 18), Op::Call(148, vec![17, 1, 2, 3, 19, 20, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![21]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_149() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(294, vec![9, 4], 1, false), Op::Call(294, vec![10, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![16, 17], 1, false), Op::Call(146, vec![0, 14, 1, 2, 7, 8, 15, 18, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 20), Op::Sub(5, 20), Op::Call(149, vec![19, 1, 2, 3, 21, 22, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![23]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 8, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_150() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![8, 4], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 17), Op::Sub(5, 17), Op::Call(150, vec![0, 1, 2, 3, 18, 19, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![20]) }), (G::from_u64(1), Block { ops: vec![Op::Call(294, vec![7, 4], 1, false), Op::Add(17, 3), Op::Call(294, vec![11, 6], 1, false), Op::Call(294, vec![12, 6], 1, false), Op::Call(147, vec![0, 1, 2, 18, 17, 9, 10, 19, 20, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 22), Op::Sub(5, 22), Op::Add(6, 22), Op::Call(150, vec![21, 1, 2, 3, 23, 24, 25, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(2, vec![26]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_151() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(294, vec![1, 15], 1, false)], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![16], 1, false), Op::Call(296, vec![4], 1, false), Op::Sub(17, 18), Op::EqZero(19), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Const(G::from_u64(0)), Op::Call(154, vec![6, 10, 5, 7, 22], 1, false), Op::Call(153, vec![23], 1, false), Op::Call(150, vec![0, 8, 9, 10, 22, 7, 22, 6, 5, 11, 12, 16, 4, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_152() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![0, 3], 1, false), Op::Add(5, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Add(3, 7), Op::Call(152, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_153() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(153, vec![3], 1, false), Op::U32LessThan(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_154() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Add(4, 7), Op::Call(154, vec![0, 1, 2, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![0, 4], 1, false), Op::Add(8, 1), Op::Const(G::from_u64(1)), Op::Sub(3, 10), Op::Add(4, 10), Op::Call(154, vec![0, 1, 2, 11, 12], 1, false), Op::Store(vec![7, 9, 13])], ctrl: Ctrl::Return(2, vec![14]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_155() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_156() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Const(G::from_u64(256)), Op::Mul(12, 5), Op::Const(G::from_u64(65536)), Op::Mul(14, 6), Op::Const(G::from_u64(16777216)), Op::Mul(16, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 11), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(4, 31), Op::AssertEq(vec![32], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(11, 33), Op::Add(10, 34), Op::Add(9, 35), Op::Add(8, 36), Op::EqZero(37), Op::Add(6, 7), Op::Add(5, 39), Op::Add(4, 40), Op::EqZero(41), Op::Const(G::from_u64(1)), Op::Sub(43, 42), Op::Mul(38, 44), Op::Sub(43, 45), Op::AssertEq(vec![46], vec![43], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(47, 48), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::Mul(12, 48), Op::Mul(14, 49), Op::Mul(16, 50), Op::Mul(18, 51), Op::Mul(20, 52), Op::Mul(22, 53), Op::Mul(24, 54), Op::Add(60, 61), Op::Add(59, 62), Op::Add(58, 63), Op::Add(57, 64), Op::Add(56, 65), Op::Add(55, 66), Op::Add(47, 67), Op::AssertEq(vec![68], vec![1], None), Op::Sub(54, 33), Op::Add(53, 69), Op::Add(52, 70), Op::Add(51, 71), Op::EqZero(72), Op::Add(49, 50), Op::Add(48, 74), Op::Add(47, 75), Op::EqZero(76), Op::Sub(43, 77), Op::Mul(73, 78), Op::Sub(43, 79), Op::AssertEq(vec![80], vec![43], None), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(81, 82), Op::U8RangeCheck(83, 84), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::Mul(12, 82), Op::Mul(14, 83), Op::Mul(16, 84), Op::Mul(18, 85), Op::Mul(20, 86), Op::Mul(22, 87), Op::Mul(24, 88), Op::Add(94, 95), Op::Add(93, 96), Op::Add(92, 97), Op::Add(91, 98), Op::Add(90, 99), Op::Add(89, 100), Op::Add(81, 101), Op::AssertEq(vec![102], vec![2], None), Op::Sub(88, 33), Op::Add(87, 103), Op::Add(86, 104), Op::Add(85, 105), Op::EqZero(106), Op::Add(83, 84), Op::Add(82, 108), Op::Add(81, 109), Op::EqZero(110), Op::Sub(43, 111), Op::Mul(107, 112), Op::Sub(43, 113), Op::AssertEq(vec![114], vec![43], None), Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(115, 116), Op::U8RangeCheck(117, 118), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::Mul(12, 116), Op::Mul(14, 117), Op::Mul(16, 118), Op::Mul(18, 119), Op::Mul(20, 120), Op::Mul(22, 121), Op::Mul(24, 122), Op::Add(128, 129), Op::Add(127, 130), Op::Add(126, 131), Op::Add(125, 132), Op::Add(124, 133), Op::Add(123, 134), Op::Add(115, 135), Op::AssertEq(vec![136], vec![3], None), Op::Sub(122, 33), Op::Add(121, 137), Op::Add(120, 138), Op::Add(119, 139), Op::EqZero(140), Op::Add(117, 118), Op::Add(116, 142), Op::Add(115, 143), Op::EqZero(144), Op::Sub(43, 145), Op::Mul(141, 146), Op::Sub(43, 147), Op::AssertEq(vec![148], vec![43], None), Op::Const(G::from_u64(0)), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Store(vec![149, 115, 116, 117, 118, 119, 120, 121, 122, 150]), Op::Store(vec![149, 81, 82, 83, 84, 85, 86, 87, 88, 151]), Op::Store(vec![149, 47, 48, 49, 50, 51, 52, 53, 54, 152]), Op::Store(vec![149, 4, 5, 6, 7, 8, 9, 10, 11, 153])], ctrl: Ctrl::Return(0, vec![154]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 58, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_157() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(7, 2), Op::EqZero(13)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(185, vec![3, 4, 15], 2, false), Op::Mul(16, 10), Op::Const(G::from_u64(7)), Op::Mul(17, 11), Op::Mul(19, 20), Op::Add(18, 21), Op::Mul(16, 11), Op::Mul(17, 10), Op::Add(23, 24), Op::Add(0, 22), Op::Add(1, 25)], ctrl: Ctrl::Return(1, vec![26, 27, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 1, 5]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 16, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_158() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Sub(6, 8), Op::EqZero(13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], None), Op::Call(300, vec![7], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![0, 1, 18]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Load(3, 5)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(6, 25), Op::Const(G::from_u64(0)), Op::Call(305, vec![11, 27], 2, false)], ctrl: Ctrl::MatchContinue(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![0, 1, 28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![28, 29, 0, 1]) })), 4, 1, 0, Box::new(Block { ops: vec![Op::Call(131, vec![24, 26, 14, 15, 30, 31, 32, 33], 2, false), Op::Call(157, vec![34, 35, 26, 14, 15, 7], 3, false), Op::Call(158, vec![36, 37, 16, 19, 12, 24, 26, 38, 8], 3, false), Op::UnconstrainedGToBytes(30), Op::U8RangeCheck(42, 43), Op::U8RangeCheck(44, 45), Op::U8RangeCheck(46, 47), Op::U8RangeCheck(48, 49), Op::Const(G::from_u64(256)), Op::Mul(50, 43), Op::Const(G::from_u64(65536)), Op::Mul(52, 44), Op::Const(G::from_u64(16777216)), Op::Mul(54, 45), Op::Const(G::from_u64(4294967296)), Op::Mul(56, 46), Op::Const(G::from_u64(1099511627776)), Op::Mul(58, 47), Op::Const(G::from_u64(281474976710656)), Op::Mul(60, 48), Op::Const(G::from_u64(72057594037927936)), Op::Mul(62, 49), Op::Add(61, 63), Op::Add(59, 64), Op::Add(57, 65), Op::Add(55, 66), Op::Add(53, 67), Op::Add(51, 68), Op::Add(42, 69), Op::AssertEq(vec![70], vec![30], None), Op::Const(G::from_u64(1020)), Op::Sub(49, 71), Op::Add(48, 72), Op::Add(47, 73), Op::Add(46, 74), Op::EqZero(75), Op::Add(44, 45), Op::Add(43, 77), Op::Add(42, 78), Op::EqZero(79), Op::Const(G::from_u64(1)), Op::Sub(81, 80), Op::Mul(76, 82), Op::Sub(81, 83), Op::AssertEq(vec![84], vec![81], None), Op::UnconstrainedGToBytes(31), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::U8RangeCheck(89, 90), Op::U8RangeCheck(91, 92), Op::Mul(50, 86), Op::Mul(52, 87), Op::Mul(54, 88), Op::Mul(56, 89), Op::Mul(58, 90), Op::Mul(60, 91), Op::Mul(62, 92), Op::Add(98, 99), Op::Add(97, 100), Op::Add(96, 101), Op::Add(95, 102), Op::Add(94, 103), Op::Add(93, 104), Op::Add(85, 105), Op::AssertEq(vec![106], vec![31], None), Op::Sub(92, 71), Op::Add(91, 107), Op::Add(90, 108), Op::Add(89, 109), Op::EqZero(110), Op::Add(87, 88), Op::Add(86, 112), Op::Add(85, 113), Op::EqZero(114), Op::Sub(81, 115), Op::Mul(111, 116), Op::Sub(81, 117), Op::AssertEq(vec![118], vec![81], None), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::U8RangeCheck(123, 124), Op::U8RangeCheck(125, 126), Op::Mul(50, 120), Op::Mul(52, 121), Op::Mul(54, 122), Op::Mul(56, 123), Op::Mul(58, 124), Op::Mul(60, 125), Op::Mul(62, 126), Op::Add(132, 133), Op::Add(131, 134), Op::Add(130, 135), Op::Add(129, 136), Op::Add(128, 137), Op::Add(127, 138), Op::Add(119, 139), Op::AssertEq(vec![140], vec![32], None), Op::Sub(126, 71), Op::Add(125, 141), Op::Add(124, 142), Op::Add(123, 143), Op::EqZero(144), Op::Add(121, 122), Op::Add(120, 146), Op::Add(119, 147), Op::EqZero(148), Op::Sub(81, 149), Op::Mul(145, 150), Op::Sub(81, 151), Op::AssertEq(vec![152], vec![81], None), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(153, 154), Op::U8RangeCheck(155, 156), Op::U8RangeCheck(157, 158), Op::U8RangeCheck(159, 160), Op::Mul(50, 154), Op::Mul(52, 155), Op::Mul(54, 156), Op::Mul(56, 157), Op::Mul(58, 158), Op::Mul(60, 159), Op::Mul(62, 160), Op::Add(166, 167), Op::Add(165, 168), Op::Add(164, 169), Op::Add(163, 170), Op::Add(162, 171), Op::Add(161, 172), Op::Add(153, 173), Op::AssertEq(vec![174], vec![33], None), Op::Sub(160, 71), Op::Add(159, 175), Op::Add(158, 176), Op::Add(157, 177), Op::EqZero(178), Op::Add(155, 156), Op::Add(154, 180), Op::Add(153, 181), Op::EqZero(182), Op::Sub(81, 183), Op::Mul(179, 184), Op::Sub(81, 185), Op::AssertEq(vec![186], vec![81], None), Op::Const(G::from_u64(0)), Op::Store(vec![81, 81, 81, 81, 81, 81, 81, 81, 81, 81]), Op::Store(vec![187, 153, 154, 155, 156, 157, 158, 159, 160, 188]), Op::Store(vec![187, 119, 120, 121, 122, 123, 124, 125, 126, 189]), Op::Store(vec![187, 85, 86, 87, 88, 89, 90, 91, 92, 190]), Op::Store(vec![187, 42, 43, 44, 45, 46, 47, 48, 49, 191]), Op::Store(vec![187, 192, 41])], ctrl: Ctrl::Return(3, vec![39, 40, 193]) })) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 89, lookups: 32 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_159() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![2], 1, false), Op::Sub(25, 24), Op::EqZero(26), Op::Const(G::from_u64(1)), Op::AssertEq(vec![27], vec![28], None), Op::Call(296, vec![1], 1, false), Op::Const(G::from_u64(3)), Op::Call(145, vec![8, 9], 1, false), Op::Add(30, 31), Op::Sub(29, 32), Op::EqZero(33), Op::AssertEq(vec![34], vec![28], None), Op::Call(142, vec![15, 19, 18, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(152, vec![15, 19, 18, 36], 1, false), Op::Call(294, vec![1, 36], 1, false)], ctrl: Ctrl::Match(38, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![38], 1, false), Op::Sub(39, 18), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::AssertEq(vec![41], vec![42], None), Op::Const(G::from_u64(0)), Op::Call(148, vec![35, 0, 20, 19, 43, 18, 15, 16, 17, 38, 5, 3, 4], 1, false), Op::Call(294, vec![1, 42], 1, false)], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![45], 1, false), Op::Sub(46, 18), Op::EqZero(47), Op::Const(G::from_u64(1)), Op::AssertEq(vec![48], vec![49], None), Op::Const(G::from_u64(0)), Op::Call(148, vec![44, 0, 20, 19, 50, 18, 15, 16, 17, 45, 6, 3, 4], 1, false), Op::Const(G::from_u64(2)), Op::Call(294, vec![1, 52], 1, false)], ctrl: Ctrl::Match(53, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![53], 1, false), Op::Sub(54, 18), Op::EqZero(55), Op::Const(G::from_u64(1)), Op::AssertEq(vec![56], vec![57], None), Op::Const(G::from_u64(0)), Op::Call(149, vec![51, 0, 20, 19, 58, 18, 15, 16, 17, 53, 7, 3, 4], 1, false), Op::Call(151, vec![59, 1, 13, 8, 9, 14, 15, 18, 0, 20, 19, 16, 17, 3, 4], 1, false), Op::Call(144, vec![60, 19], 1, false), Op::Load(7, 60)], ctrl: Ctrl::Match(62, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(63, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(63, 20), Op::EqZero(69), Op::Const(G::from_u64(1)), Op::AssertEq(vec![70], vec![71], None), Op::Call(158, vec![66, 67, 21, 22, 2, 0, 20, 68, 19], 3, false), Op::Const(G::from_u64(0)), Op::Call(305, vec![23, 75], 2, false), Op::Sub(76, 72), Op::EqZero(78), Op::Sub(77, 73), Op::EqZero(80), Op::Mul(79, 81), Op::AssertEq(vec![82], vec![71], None)], ctrl: Ctrl::Return(0, vec![74]) }))) })].into_iter().collect(), None) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 25, selectors: 1, auxiliaries: 46, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_160() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29])], ctrl: Ctrl::Return(0, vec![30]) }), (G::from_u64(0), Block { ops: vec![Op::Call(179, vec![0, 1, 20], 3, false), Op::Call(159, vec![29, 26, 27, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Const(G::from_u64(0)), Op::Call(160, vec![30, 31, 28, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Store(vec![33, 32, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_161() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![0, 1, 3], 3, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(161, vec![5, 6, 9, 3], 1, false), Op::Store(vec![7, 4, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_162() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![3, 1], 1, false), Op::Call(162, vec![5, 1], 1, false), Op::Store(vec![6, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_163() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![4, 1], 1, false), Op::Call(163, vec![6, 1], 1, false), Op::Store(vec![7, 3, 8, 9])], ctrl: Ctrl::Return(1, vec![10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_164() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(162, vec![0, 2], 1, false), Op::Call(163, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Sub(3, 7), Op::Call(164, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 5, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_165() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(152, vec![9, 11, 10, 13], 1, false), Op::Call(305, vec![0, 13], 2, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(305, vec![0, 17], 2, false)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(305, vec![0, 20], 2, false)], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(128, vec![2, 15, 14, 1, 16, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![23], vec![24], None), Op::Call(128, vec![3, 18, 14, 1, 19, 12], 1, false), Op::AssertEq(vec![25], vec![24], None), Op::Call(128, vec![4, 21, 14, 1, 22, 12], 1, false), Op::AssertEq(vec![26], vec![24], None)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(305, vec![0, 27], 2, false)], ctrl: Ctrl::Match(28, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(154, vec![9, 11, 8, 10, 30], 1, false), Op::Call(153, vec![31], 1, false), Op::Sub(12, 32), Op::Call(166, vec![1, 33], 1, false), Op::Call(128, vec![5, 28, 31, 34, 29, 32], 1, false)], ctrl: Ctrl::Return(1, vec![35]) }))) })].into_iter().collect(), None) }))) }))) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 17, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_166() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(308, vec![3, 1], 1, false), Op::Call(166, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_167() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(294, vec![3, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![5, 6, 8]), Op::Call(167, vec![4, 1], 1, false), Op::Store(vec![5, 9, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_168() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(296, vec![1], 1, false), Op::EqZero(11)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![14], None), Op::Call(296, vec![8], 1, false), Op::Call(296, vec![3], 1, false), Op::AssertEq(vec![15], vec![16], None), Op::Call(166, vec![3, 14], 1, false), Op::Sub(5, 14), Op::Call(167, vec![2, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14]), Op::Store(vec![20, 18, 21]), Op::Call(128, vec![12, 19, 22, 17, 9, 18], 1, false), Op::AssertEq(vec![23], vec![14], None), Op::Add(4, 14), Op::Call(168, vec![10, 13, 2, 17, 24, 18], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_169() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![6], 1, false), Op::Call(301, vec![7], 1, false), Op::Sub(33, 32), Op::EqZero(34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(297, vec![8], 1, false), Op::Const(G::from_u64(3)), Op::Call(145, vec![4, 5], 1, false), Op::Add(38, 39), Op::AssertEq(vec![37], vec![40], None), Op::Call(307, vec![9], 1, false), Op::Sub(41, 32), Op::EqZero(42), Op::AssertEq(vec![43], vec![36], None), Op::Call(297, vec![10], 1, false), Op::AssertEq(vec![44], vec![36], None), Op::Store(vec![36, 36, 36])], ctrl: Ctrl::MatchContinue(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![45]) }), (G::from_u64(1), Block { ops: vec![Op::Call(136, vec![5, 45], 1, false)], ctrl: Ctrl::Yield(1, vec![46]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(136, vec![3, 46], 1, false), Op::Call(136, vec![2, 47], 1, false), Op::Call(136, vec![1, 48], 1, false), Op::Call(298, vec![0, 49], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Call(177, vec![50, 52], 18, false), Op::Const(G::from_u64(256)), Op::Mul(71, 54), Op::Const(G::from_u64(65536)), Op::Mul(73, 55), Op::Const(G::from_u64(16777216)), Op::Mul(75, 56), Op::Const(G::from_u64(4294967296)), Op::Mul(77, 57), Op::Const(G::from_u64(1099511627776)), Op::Mul(79, 58), Op::Const(G::from_u64(281474976710656)), Op::Mul(81, 59), Op::Const(G::from_u64(72057594037927936)), Op::Mul(83, 60), Op::Add(82, 84), Op::Add(80, 85), Op::Add(78, 86), Op::Add(76, 87), Op::Add(74, 88), Op::Add(72, 89), Op::Add(53, 90), Op::Mul(71, 62), Op::Mul(73, 63), Op::Mul(75, 64), Op::Mul(77, 65), Op::Mul(79, 66), Op::Mul(81, 67), Op::Mul(83, 68), Op::Add(97, 98), Op::Add(96, 99), Op::Add(95, 100), Op::Add(94, 101), Op::Add(93, 102), Op::Add(92, 103), Op::Add(61, 104), Op::Call(140, vec![69, 6, 7, 30], 2, false), Op::Call(134, vec![10, 52], 1, false), Op::Call(298, vec![107, 108], 1, false), Op::Call(138, vec![109, 6], 1, false), Op::Call(139, vec![110, 11, 12, 13, 14, 15, 16, 17, 18, 31], 2, false), Op::Add(32, 28), Op::Const(G::from_u64(33)), Op::U32LessThan(113, 114), Op::AssertEq(vec![115], vec![51], None), Op::Call(161, vec![111, 112, 29, 113], 1, false), Op::Call(165, vec![8, 116, 19, 20, 21, 22, 4, 5, 23, 24, 27, 28, 113], 1, false), Op::AssertEq(vec![117], vec![51], None), Op::Const(G::from_u64(0)), Op::Call(164, vec![8, 9, 118, 29], 1, false), Op::Call(160, vec![111, 112, 119, 91, 105, 1, 2, 3, 4, 5, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 113, 106, 6, 10, 32], 1, false), Op::Call(168, vec![9, 6, 120, 116, 118, 113], 1, false)], ctrl: Ctrl::Return(2, vec![121]) })) }))) }, layout: FunctionLayout { input_size: 32, selectors: 3, auxiliaries: 55, lookups: 31 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_170() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::EqZero(1), Op::Mul(2, 3)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_171() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 7, 8]), Op::Store(vec![9, 6, 10]), Op::Store(vec![9, 5, 11]), Op::Store(vec![9, 4, 12]), Op::Store(vec![9, 3, 13]), Op::Store(vec![9, 2, 14]), Op::Store(vec![9, 1, 15]), Op::Store(vec![9, 0, 16])], ctrl: Ctrl::Return(0, vec![17]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_172() -> Function { + Function { body: Block { ops: vec![Op::Call(171, vec![24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(171, vec![16, 17, 18, 19, 20, 21, 22, 23, 33], 1, false), Op::Call(171, vec![8, 9, 10, 11, 12, 13, 14, 15, 34], 1, false), Op::Call(171, vec![0, 1, 2, 3, 4, 5, 6, 7, 35], 1, false)], ctrl: Ctrl::Return(0, vec![36]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_173() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Call(173, vec![4, 1], 1, false), Op::Call(171, vec![29, 30, 31, 32, 33, 34, 35, 36, 37], 1, false), Op::Call(171, vec![21, 22, 23, 24, 25, 26, 27, 28, 38], 1, false), Op::Call(171, vec![13, 14, 15, 16, 17, 18, 19, 20, 39], 1, false), Op::Call(171, vec![5, 6, 7, 8, 9, 10, 11, 12, 40], 1, false)], ctrl: Ctrl::Return(1, vec![41]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 41, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_174() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(174, vec![4, 1], 1, false), Op::Call(171, vec![3, 5, 5, 5, 5, 5, 5, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_175() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Const(G::from_u64(0)), Op::Store(vec![38, 38, 38, 38, 38, 38, 38, 38]), Op::Store(vec![5, 6, 7, 8, 9, 10, 5, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36]), Op::Call(78, vec![0, 37, 38, 38, 39, 40, 41], 1, false), Op::Call(77, vec![42], 32, false), Op::Call(108, vec![71, 72, 73, 74, 37], 1, false), Op::Call(108, vec![67, 68, 69, 70, 75], 1, false), Op::Call(108, vec![63, 64, 65, 66, 76], 1, false), Op::Call(108, vec![59, 60, 61, 62, 77], 1, false), Op::Call(108, vec![55, 56, 57, 58, 78], 1, false), Op::Call(108, vec![51, 52, 53, 54, 79], 1, false), Op::Call(108, vec![47, 48, 49, 50, 80], 1, false), Op::Call(108, vec![43, 44, 45, 46, 81], 1, false), Op::Call(129, vec![82, 37], 1, false), Op::Load(3, 83)], ctrl: Ctrl::Match(84, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 89)], ctrl: Ctrl::Match(90, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(93, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 95)], ctrl: Ctrl::Match(96, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 98)], ctrl: Ctrl::Match(99, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 101)], ctrl: Ctrl::Match(102, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 104)], ctrl: Ctrl::Match(105, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![85, 88, 91, 94, 97, 100, 103, 106, 82, 107]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 6, 9, 12, 15, 18, 21, 24, 0, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_176() -> Function { + Function { body: Block { ops: vec![Op::Call(175, vec![0, 1], 10, false), Op::Const(G::from_u64(1020)), Op::Sub(9, 12), Op::Add(8, 13), Op::Add(7, 14), Op::Add(6, 15), Op::EqZero(16), Op::Add(4, 5), Op::Add(3, 18), Op::Add(2, 19), Op::EqZero(20), Op::Const(G::from_u64(1)), Op::Sub(22, 21), Op::Mul(17, 23), Op::Sub(22, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![10, 11], 10, false)], ctrl: Ctrl::Return(1, vec![26, 27, 28, 29, 30, 31, 32, 33, 34, 35]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 27, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_177() -> Function { + Function { body: Block { ops: vec![Op::Call(176, vec![0, 1], 10, false), Op::Call(176, vec![10, 11], 10, false)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 21, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_178() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(178, vec![4, 7], 1, false), Op::Store(vec![5, 3, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_179() -> Function { + Function { body: Block { ops: vec![Op::Call(175, vec![0, 1], 10, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4), Op::U8BitDecomposition(5), Op::U8BitDecomposition(6), Op::Const(G::from_u64(1)), Op::Store(vec![45, 45, 45]), Op::Call(171, vec![37, 38, 39, 40, 41, 42, 43, 44, 46], 1, false), Op::Call(171, vec![29, 30, 31, 32, 33, 34, 35, 36, 47], 1, false), Op::Call(171, vec![21, 22, 23, 24, 25, 26, 27, 28, 48], 1, false), Op::Call(171, vec![13, 14, 15, 16, 17, 18, 19, 20, 49], 1, false), Op::Call(178, vec![50, 2], 1, false)], ctrl: Ctrl::Return(0, vec![51, 11, 12]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 49, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_180() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(171, vec![1, 2, 3, 4, 5, 6, 7, 8, 10], 1, false), Op::Call(298, vec![0, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_181() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(173, vec![1, 3], 1, false), Op::Call(298, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_182() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![1, 14, 0]), Op::Store(vec![1, 13, 15]), Op::Store(vec![1, 12, 16]), Op::Store(vec![1, 11, 17]), Op::Store(vec![1, 10, 18]), Op::Store(vec![1, 9, 19]), Op::Store(vec![1, 5, 20]), Op::Store(vec![1, 8, 21]), Op::Store(vec![1, 7, 22]), Op::Store(vec![1, 6, 23]), Op::Store(vec![1, 5, 24]), Op::Store(vec![1, 4, 25]), Op::Store(vec![1, 3, 26]), Op::Store(vec![1, 2, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 15 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_183() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(183, vec![11, 1], 1, false), Op::Call(171, vec![3, 4, 5, 6, 7, 8, 9, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_184() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_185() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(4, 5), Op::Add(3, 6), Op::Mul(0, 1), Op::Mul(1, 0), Op::Add(8, 9), Op::Const(G::from_u64(1)), Op::Sub(2, 11), Op::Call(185, vec![7, 10, 12], 2, false)], ctrl: Ctrl::Return(1, vec![13, 14]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_186() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1753635133440165772))], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 1), Op::Call(186, vec![2], 1, false), Op::Mul(3, 3)], ctrl: Ctrl::Return(2, vec![4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_187() -> Function { + Function { body: Block { ops: vec![Op::Call(185, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6)], ctrl: Ctrl::Return(0, vec![7, 8]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_188() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Sub(0, 2), Op::Call(188, vec![3], 1, false), Op::Mul(1, 4)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_189() -> Function { + Function { body: Block { ops: vec![Op::Call(185, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6), Op::Call(186, vec![2], 1, false), Op::UnconstrainedGInverse(9), Op::Mul(9, 10), Op::Sub(11, 5), Op::Mul(9, 12), Op::AssertEq(vec![13], vec![6], None), Op::Mul(10, 12), Op::AssertEq(vec![14], vec![6], None), Op::Sub(0, 5), Op::Sub(1, 6), Op::Mul(15, 15), Op::Const(G::from_u64(7)), Op::Mul(16, 16), Op::Mul(18, 19), Op::Sub(17, 20), Op::UnconstrainedGInverse(21), Op::Mul(21, 22), Op::Sub(23, 5), Op::Mul(21, 24), Op::AssertEq(vec![25], vec![6], None), Op::Mul(22, 24), Op::AssertEq(vec![26], vec![6], None), Op::Mul(15, 22), Op::Sub(6, 16), Op::Mul(28, 22), Op::Mul(7, 27), Op::Mul(8, 29), Op::Mul(18, 31), Op::Add(30, 32), Op::Mul(7, 29), Op::Mul(8, 27), Op::Add(34, 35), Op::Sub(0, 10), Op::Mul(37, 37), Op::Sub(38, 20), Op::UnconstrainedGInverse(39), Op::Mul(39, 40), Op::Sub(41, 5), Op::Mul(39, 42), Op::AssertEq(vec![43], vec![6], None), Op::Mul(40, 42), Op::AssertEq(vec![44], vec![6], None), Op::Mul(37, 40), Op::Mul(28, 40), Op::Mul(7, 45), Op::Mul(8, 46), Op::Mul(18, 48), Op::Add(47, 49), Op::Mul(7, 46), Op::Mul(8, 45), Op::Add(51, 52), Op::Mul(7, 7), Op::Mul(8, 8), Op::Mul(18, 55), Op::Sub(54, 56), Op::UnconstrainedGInverse(57), Op::Mul(57, 58), Op::Sub(59, 5), Op::Mul(57, 60), Op::AssertEq(vec![61], vec![6], None), Op::Mul(58, 60), Op::AssertEq(vec![62], vec![6], None), Op::Mul(7, 58), Op::Sub(6, 8), Op::Mul(64, 58)], ctrl: Ctrl::Return(0, vec![33, 36, 50, 53, 37, 16, 63, 65]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 39, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_190() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(11, 12), Op::Add(10, 4), Op::Add(13, 5)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_191() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Mul(2, 4), Op::Const(G::from_u64(7)), Op::Mul(3, 5), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(11, 12), Op::Add(0, 10), Op::Add(1, 13)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_192() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(191, vec![2, 3, 6, 7], 2, false), Op::Call(192, vec![8], 1, false), Op::Store(vec![9, 10, 11, 12])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_193() -> Function { + Function { body: Block { ops: vec![Op::Call(303, vec![0, 1], 4, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![16, 19]) }), (G::from_u64(1), Block { ops: vec![Op::Add(16, 17), Op::Add(16, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(305, vec![4, 18], 2, false)], ctrl: Ctrl::Return(1, vec![21, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Call(305, vec![5, 18], 2, false)], ctrl: Ctrl::Return(2, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(305, vec![2, 18], 2, false)], ctrl: Ctrl::Return(3, vec![21, 22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(305, vec![3, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }), (G::from_u64(4), Block { ops: vec![Op::Call(305, vec![6, 18], 2, false)], ctrl: Ctrl::Return(5, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(305, vec![7, 18], 2, false)], ctrl: Ctrl::Return(6, vec![21, 22]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(305, vec![8, 16], 2, false)], ctrl: Ctrl::Return(7, vec![19, 20]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(8, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![11, 12]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(10, vec![13, 14]) }), (G::from_u64(6), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(193, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Add(19, 21), Op::Add(20, 22)], ctrl: Ctrl::Return(11, vec![23, 24]) }), (G::from_u64(7), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(193, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Sub(19, 21), Op::Sub(20, 22)], ctrl: Ctrl::Return(12, vec![23, 24]) }), (G::from_u64(8), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(193, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Mul(19, 21), Op::Const(G::from_u64(7)), Op::Mul(20, 22), Op::Mul(24, 25), Op::Add(23, 26), Op::Mul(19, 22), Op::Mul(20, 21), Op::Add(28, 29)], ctrl: Ctrl::Return(13, vec![27, 30]) }), (G::from_u64(9), Block { ops: vec![Op::Call(193, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Const(G::from_u64(0)), Op::Sub(21, 19), Op::Sub(21, 20)], ctrl: Ctrl::Return(14, vec![22, 23]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_194() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(193, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Call(190, vec![0, 1, 2, 3, 22, 23], 2, false), Op::Call(194, vec![24, 25, 2, 3, 21, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_195() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 4), Op::Const(G::from_u64(7)), Op::Mul(1, 5), Op::Mul(9, 10), Op::Add(8, 11), Op::Mul(0, 5), Op::Mul(1, 4), Op::Add(13, 14), Op::Const(G::from_u64(0)), Op::Mul(2, 6), Op::Mul(3, 7), Op::Mul(9, 18), Op::Add(17, 19), Op::Mul(2, 7), Op::Mul(3, 6), Op::Add(21, 22), Op::Mul(9, 20), Op::Mul(16, 23), Op::Mul(9, 25), Op::Add(24, 26), Op::Mul(9, 23), Op::Mul(16, 20), Op::Add(28, 29), Op::Add(12, 27), Op::Add(15, 30), Op::Mul(0, 6), Op::Mul(1, 7), Op::Mul(9, 34), Op::Add(33, 35), Op::Mul(0, 7), Op::Mul(1, 6), Op::Add(37, 38), Op::Mul(2, 4), Op::Mul(3, 5), Op::Mul(9, 41), Op::Add(40, 42), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(44, 45), Op::Add(36, 43), Op::Add(39, 46)], ctrl: Ctrl::Return(0, vec![31, 32, 47, 48]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 17, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_196() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![22, 22, 22, 22]) }), (G::from_u64(0), Block { ops: vec![Op::Call(196, vec![21, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 4, false), Op::Call(195, vec![22, 23, 24, 25, 1, 2, 3, 4], 4, false), Op::Call(193, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Add(26, 30), Op::Add(27, 31)], ctrl: Ctrl::Return(1, vec![32, 33, 28, 29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 14, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_197() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(196, vec![46, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 4, false), Op::Add(48, 22), Op::Add(49, 23), Op::Add(50, 24), Op::Add(51, 25), Op::Call(193, vec![30, 45, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false), Op::Call(195, vec![14, 15, 16, 17, 52, 53, 54, 55], 4, false), Op::Mul(56, 10), Op::Const(G::from_u64(7)), Op::Mul(57, 11), Op::Mul(63, 64), Op::Add(62, 65), Op::Mul(56, 11), Op::Mul(57, 10), Op::Add(67, 68), Op::Add(58, 66), Op::Add(59, 69), Op::Mul(56, 12), Op::Mul(57, 13), Op::Mul(63, 73), Op::Add(72, 74), Op::Mul(56, 13), Op::Mul(57, 12), Op::Add(76, 77), Op::Add(60, 75), Op::Add(61, 78), Op::Call(195, vec![10, 11, 12, 13, 52, 53, 54, 55], 4, false), Op::Const(G::from_u64(1)), Op::Sub(85, 6), Op::Add(5, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(305, vec![35, 88], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 91), Op::Add(7, 92), Op::Call(305, vec![35, 93], 2, false), Op::Const(G::from_u64(0)), Op::Call(305, vec![36, 96], 2, false), Op::Add(97, 18), Op::Add(98, 19), Op::Call(305, vec![36, 91], 2, false), Op::Add(101, 20), Op::Add(102, 21), Op::Sub(99, 89), Op::Sub(100, 90), Op::Sub(103, 94), Op::Sub(104, 95), Op::Call(195, vec![81, 82, 83, 84, 105, 106, 107, 108], 4, false), Op::Sub(109, 70), Op::Sub(110, 71), Op::Call(190, vec![0, 1, 2, 3, 113, 114], 2, false), Op::Sub(111, 79), Op::Sub(112, 80), Op::Call(190, vec![115, 116, 2, 3, 117, 118], 2, false)], ctrl: Ctrl::Return(1, vec![119, 120]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(8, 88)], ctrl: Ctrl::Match(89, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(305, vec![35, 90], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 93), Op::Add(7, 94), Op::Call(305, vec![35, 95], 2, false), Op::Const(G::from_u64(2)), Op::Add(7, 98), Op::Add(7, 99), Op::Call(305, vec![35, 100], 2, false), Op::Const(G::from_u64(3)), Op::Add(7, 103), Op::Add(7, 104), Op::Call(305, vec![35, 105], 2, false), Op::Sub(101, 91), Op::Sub(102, 92), Op::Sub(106, 96), Op::Sub(107, 97), Op::Call(195, vec![81, 82, 83, 84, 108, 109, 110, 111], 4, false), Op::Sub(112, 70), Op::Sub(113, 71), Op::Call(190, vec![0, 1, 2, 3, 116, 117], 2, false), Op::Sub(114, 79), Op::Sub(115, 80), Op::Call(190, vec![118, 119, 2, 3, 120, 121], 2, false), Op::Add(5, 93), Op::Const(G::from_u64(0)), Op::Call(197, vec![122, 123, 2, 3, 47, 124, 6, 94, 9, 9, 93, 125, 125, 125, 125, 125, 125, 125, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(2, vec![126, 127]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 90), Op::Sub(8, 90), Op::Call(197, vec![0, 1, 2, 3, 47, 91, 6, 7, 92, 9, 81, 82, 83, 84, 70, 71, 79, 80, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(3, vec![93, 94]) }))) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 44, selectors: 4, auxiliaries: 46, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_198() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(194, vec![28, 28, 25, 26, 1, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false), Op::Sub(17, 15), Op::Sub(28, 28), Op::Mul(31, 27), Op::Const(G::from_u64(7)), Op::Mul(32, 28), Op::Mul(34, 35), Op::Add(33, 36), Op::Mul(31, 28), Op::Mul(32, 27), Op::Add(38, 39), Op::Mul(21, 37), Op::Mul(22, 40), Op::Mul(34, 42), Op::Add(41, 43), Op::Mul(21, 40), Op::Mul(22, 37), Op::Add(45, 46), Op::Sub(18, 16), Op::Mul(48, 27), Op::Add(49, 36), Op::Mul(48, 28), Op::Add(51, 39), Op::Mul(21, 50), Op::Mul(22, 52), Op::Mul(34, 54), Op::Add(53, 55), Op::Mul(21, 52), Op::Mul(22, 50), Op::Add(57, 58), Op::Load(4, 2)], ctrl: Ctrl::Match(60, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(305, vec![9, 64], 2, false), Op::Call(305, vec![8, 64], 2, false), Op::Sub(65, 67), Op::Sub(66, 68), Op::Add(69, 44), Op::Add(70, 47), Op::Call(190, vec![29, 30, 25, 26, 71, 72], 2, false), Op::Const(G::from_u64(1)), Op::Call(305, vec![9, 75], 2, false), Op::Call(305, vec![8, 75], 2, false), Op::Sub(76, 78), Op::Sub(77, 79), Op::Add(80, 56), Op::Add(81, 59), Op::Call(190, vec![73, 74, 25, 26, 82, 83], 2, false)], ctrl: Ctrl::Return(0, vec![84, 85]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(297, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::Call(197, vec![29, 30, 25, 26, 2, 64, 65, 64, 3, 3, 66, 64, 64, 64, 64, 64, 64, 64, 44, 47, 56, 59, 11, 28, 12, 28, 13, 28, 14, 28, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 28, selectors: 2, auxiliaries: 29, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_199() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![8, 7, 8, 10]), Op::Store(vec![8, 6, 8, 11]), Op::Store(vec![8, 5, 8, 12]), Op::Store(vec![8, 4, 8, 13]), Op::Store(vec![8, 3, 8, 14]), Op::Store(vec![8, 2, 8, 15]), Op::Store(vec![8, 1, 8, 16]), Op::Store(vec![8, 0, 8, 17])], ctrl: Ctrl::Return(0, vec![18]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 10, lookups: 10 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_200() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 9]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(3, 6), Op::Const(G::from_u64(7)), Op::Mul(4, 7), Op::Mul(10, 11), Op::Add(9, 12), Op::Mul(3, 7), Op::Mul(4, 6), Op::Add(14, 15), Op::Mul(3, 1), Op::Mul(4, 2), Op::Mul(10, 18), Op::Add(17, 19), Op::Mul(3, 2), Op::Mul(4, 1), Op::Add(21, 22), Op::Call(200, vec![8, 1, 2, 20, 23], 2, false), Op::Add(13, 24), Op::Add(16, 25)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_201() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(17, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(18, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 19, auxiliaries: 19, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_202() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(1, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![Op::Call(294, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(294, vec![4, 7], 1, false)], ctrl: Ctrl::Return(2, vec![6, 8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 4, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_203() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![31]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(294, vec![2, 9], 1, false), Op::Const(G::from_u64(32)), Op::U8LessThan(31, 32), Op::Const(G::from_u64(1)), Op::AssertEq(vec![33], vec![34], None), Op::Call(201, vec![24], 1, false), Op::Call(305, vec![3, 9], 2, false), Op::Call(294, vec![4, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![38, 39], 1, false), Op::Call(294, vec![38, 34], 1, false), Op::Call(294, vec![5, 9], 1, false), Op::Call(294, vec![42, 39], 1, false), Op::Call(294, vec![42, 34], 1, false), Op::Call(305, vec![1, 9], 2, false)], ctrl: Ctrl::MatchContinue(45, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(1, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(2, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![Op::Call(294, vec![7, 46], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![47, 48], 1, false), Op::Const(G::from_u64(1)), Op::Call(294, vec![47, 50], 1, false)], ctrl: Ctrl::Yield(3, vec![49, 51]) })].into_iter().collect(), None) })].into_iter().collect(), None, 2, 3, 3, Box::new(Block { ops: vec![Op::Call(297, vec![40], 1, false), Op::Sub(49, 27), Op::EqZero(50), Op::Const(G::from_u64(1)), Op::AssertEq(vec![51], vec![52], None), Op::Call(297, vec![41], 1, false), Op::Sub(53, 27), Op::EqZero(54), Op::AssertEq(vec![55], vec![52], None), Op::Call(297, vec![43], 1, false), Op::Sub(56, 29), Op::EqZero(57), Op::AssertEq(vec![58], vec![52], None), Op::Call(297, vec![44], 1, false), Op::Sub(59, 29), Op::EqZero(60), Op::AssertEq(vec![61], vec![52], None), Op::Call(297, vec![47], 1, false), Op::Sub(62, 28), Op::EqZero(63), Op::AssertEq(vec![64], vec![52], None), Op::Call(297, vec![48], 1, false), Op::Sub(65, 28), Op::EqZero(66), Op::AssertEq(vec![67], vec![52], None), Op::Call(185, vec![18, 19, 31], 2, false), Op::Const(G::from_u64(0)), Op::Sub(68, 52), Op::Sub(69, 70), Op::Call(186, vec![31], 1, false), Op::UnconstrainedGInverse(73), Op::Mul(73, 74), Op::Sub(75, 52), Op::Mul(73, 76), Op::AssertEq(vec![77], vec![70], None), Op::Mul(74, 76), Op::AssertEq(vec![78], vec![70], None), Op::Sub(18, 52), Op::Sub(19, 70), Op::Mul(79, 79), Op::Const(G::from_u64(7)), Op::Mul(80, 80), Op::Mul(82, 83), Op::Sub(81, 84), Op::UnconstrainedGInverse(85), Op::Mul(85, 86), Op::Sub(87, 52), Op::Mul(85, 88), Op::AssertEq(vec![89], vec![70], None), Op::Mul(86, 88), Op::AssertEq(vec![90], vec![70], None), Op::Mul(79, 86), Op::Sub(70, 80), Op::Mul(92, 86), Op::Mul(71, 91), Op::Mul(72, 93), Op::Mul(82, 95), Op::Add(94, 96), Op::Mul(71, 93), Op::Mul(72, 91), Op::Add(98, 99), Op::Sub(18, 74), Op::Mul(101, 101), Op::Sub(102, 84), Op::UnconstrainedGInverse(103), Op::Mul(103, 104), Op::Sub(105, 52), Op::Mul(103, 106), Op::AssertEq(vec![107], vec![70], None), Op::Mul(104, 106), Op::AssertEq(vec![108], vec![70], None), Op::Mul(101, 104), Op::Mul(92, 104), Op::Mul(71, 109), Op::Mul(72, 110), Op::Mul(82, 112), Op::Add(111, 113), Op::Mul(71, 110), Op::Mul(72, 109), Op::Add(115, 116), Op::Mul(71, 71), Op::Mul(72, 72), Op::Mul(82, 119), Op::Sub(118, 120), Op::UnconstrainedGInverse(121), Op::Mul(121, 122), Op::Sub(123, 52), Op::Mul(121, 124), Op::AssertEq(vec![125], vec![70], None), Op::Mul(122, 124), Op::AssertEq(vec![126], vec![70], None), Op::Mul(71, 122), Op::Sub(70, 72), Op::Mul(128, 122), Op::Store(vec![52, 52, 52, 52]), Op::Store(vec![70, 37, 70, 130]), Op::Store(vec![70, 36, 70, 131]), Op::Store(vec![70, 11, 70, 132]), Op::Store(vec![70, 10, 70, 133]), Op::Store(vec![70, 15, 70, 134]), Op::Store(vec![70, 14, 70, 135]), Op::Store(vec![70, 13, 70, 136]), Op::Store(vec![70, 12, 70, 137]), Op::Call(188, vec![31], 1, false), Op::Call(186, vec![31], 1, false), Op::Mul(139, 140), Op::UnconstrainedGInverse(141), Op::Mul(141, 142), Op::Sub(143, 52), Op::Mul(141, 144), Op::AssertEq(vec![145], vec![70], None), Op::Mul(142, 144), Op::AssertEq(vec![146], vec![70], None), Op::Call(194, vec![70, 70, 16, 17, 23, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false), Op::Sub(36, 10), Op::Sub(70, 70), Op::Mul(149, 142), Op::Mul(150, 70), Op::Mul(82, 152), Op::Add(151, 153), Op::Mul(149, 70), Op::Mul(150, 142), Op::Add(155, 156), Op::Mul(114, 154), Op::Mul(117, 157), Op::Mul(82, 159), Op::Add(158, 160), Op::Mul(114, 157), Op::Mul(117, 154), Op::Add(162, 163), Op::Sub(37, 11), Op::Mul(165, 142), Op::Add(166, 153), Op::Mul(165, 70), Op::Add(168, 156), Op::Mul(114, 167), Op::Mul(117, 169), Op::Mul(82, 171), Op::Add(170, 172), Op::Mul(114, 169), Op::Mul(117, 167), Op::Add(174, 175), Op::Load(4, 25)], ctrl: Ctrl::MatchContinue(177, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(305, vec![44, 181], 2, false), Op::Call(305, vec![43, 181], 2, false), Op::Sub(182, 184), Op::Sub(183, 185), Op::Add(186, 161), Op::Add(187, 164), Op::Call(190, vec![147, 148, 16, 17, 188, 189], 2, false), Op::Const(G::from_u64(1)), Op::Call(305, vec![44, 192], 2, false), Op::Call(305, vec![43, 192], 2, false), Op::Sub(193, 195), Op::Sub(194, 196), Op::Add(197, 173), Op::Add(198, 176), Op::Call(190, vec![190, 191, 16, 17, 199, 200], 2, false)], ctrl: Ctrl::Yield(4, vec![201, 202]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(297, vec![25], 1, false), Op::Const(G::from_u64(1)), Op::Call(197, vec![147, 148, 16, 17, 25, 181, 182, 181, 26, 26, 183, 181, 181, 181, 181, 181, 181, 181, 161, 164, 173, 176, 12, 70, 13, 70, 14, 70, 15, 70, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false)], ctrl: Ctrl::Yield(5, vec![184, 185]) })].into_iter().collect(), None, 2, 12, 6, Box::new(Block { ops: vec![Op::Call(294, vec![8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(294, vec![183, 184], 1, false), Op::Call(192, vec![185], 1, false), Op::Call(297, vec![186], 1, false), Op::Sub(187, 35), Op::EqZero(188), Op::Const(G::from_u64(1)), Op::AssertEq(vec![189], vec![190], None), Op::Call(185, vec![18, 19, 31], 2, false), Op::Call(200, vec![186, 191, 192, 190, 184], 2, false), Op::Mul(181, 127), Op::Const(G::from_u64(7)), Op::Mul(182, 129), Op::Mul(196, 197), Op::Add(195, 198), Op::Mul(181, 129), Op::Mul(182, 127), Op::Add(200, 201), Op::Sub(199, 193), Op::EqZero(203), Op::Sub(202, 194), Op::EqZero(205), Op::Mul(204, 206), Op::AssertEq(vec![207], vec![190], None), Op::Add(9, 190), Op::Call(203, vec![30, 1, 2, 3, 4, 5, 6, 7, 8, 208, 36, 37, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Return(6, vec![209]) })) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 20, selectors: 7, auxiliaries: 152, lookups: 50 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_204() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![13, 13]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(13, 5), Op::Const(G::from_u64(65536)), Op::Mul(15, 6), Op::Const(G::from_u64(16777216)), Op::Mul(17, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 11), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(4, 32), Op::Const(G::from_u64(0)), Op::Call(204, vec![0, 1, 12], 2, false), Op::Mul(0, 35), Op::Const(G::from_u64(7)), Op::Mul(1, 36), Op::Mul(38, 39), Op::Add(37, 40), Op::Mul(0, 36), Op::Mul(1, 35), Op::Add(42, 43), Op::Add(33, 41), Op::Add(34, 44)], ctrl: Ctrl::Return(1, vec![45, 46]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 17, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_205() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(204, vec![5, 6, 8], 2, false), Op::Add(3, 10), Op::Add(4, 11), Op::Mul(12, 12), Op::Const(G::from_u64(7)), Op::Mul(13, 13), Op::Mul(15, 16), Op::Sub(14, 17), Op::UnconstrainedGInverse(18), Op::Mul(18, 19), Op::Const(G::from_u64(1)), Op::Sub(20, 21), Op::Mul(18, 22), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None), Op::Mul(19, 22), Op::AssertEq(vec![25], vec![24], None), Op::Mul(12, 19), Op::Sub(24, 13), Op::Mul(27, 19), Op::Add(0, 26), Op::Add(1, 28), Op::Call(205, vec![29, 30, 9, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![31, 32]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_206() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 4), Op::Mul(2, 5), Op::Const(G::from_u64(0)), Op::AssertEq(vec![6], vec![7], None), Op::Call(206, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_207() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Call(207, vec![12, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(207, vec![12, 15], 1, false), Op::Store(vec![16, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17])], ctrl: Ctrl::Return(2, vec![18]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_208() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(208, vec![5, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(208, vec![5, 8], 1, false), Op::Store(vec![9, 3, 4, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_209() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(2, 3), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Const(G::from_u64(65536)), Op::Mul(12, 4), Op::Const(G::from_u64(16777216)), Op::Mul(14, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 9), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(2, 29), Op::AssertEq(vec![30], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(9, 31), Op::Add(8, 32), Op::Add(7, 33), Op::Add(6, 34), Op::EqZero(35), Op::Add(4, 5), Op::Add(3, 37), Op::Add(2, 38), Op::EqZero(39), Op::Const(G::from_u64(1)), Op::Sub(41, 40), Op::Mul(36, 42), Op::Sub(41, 43), Op::AssertEq(vec![44], vec![41], None), Op::Call(171, vec![2, 3, 4, 5, 6, 7, 8, 9, 1], 1, false)], ctrl: Ctrl::Return(0, vec![45]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_210() -> Function { + Function { body: Block { ops: vec![Op::Call(296, vec![0], 1, false), Op::Call(211, vec![0, 1], 1, false), Op::Call(209, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_211() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(301, vec![3], 1, false), Op::Call(211, vec![4, 1], 1, false), Op::Call(183, vec![3, 6], 1, false), Op::Call(209, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_212() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![2], 1, false), Op::Call(210, vec![3, 4], 1, false), Op::Call(174, vec![2, 6], 1, false), Op::Call(209, vec![5, 7], 1, false), Op::Call(173, vec![1, 8], 1, false), Op::Call(174, vec![0, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_213() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(213, vec![7, 1], 1, false), Op::Call(212, vec![3, 4, 5, 6, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_214() -> Function { + Function { body: Block { ops: vec![Op::Call(302, vec![0], 1, false), Op::Call(215, vec![0, 1], 1, false), Op::Call(209, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_215() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![3], 1, false), Op::Call(215, vec![12, 1], 1, false), Op::Call(171, vec![4, 5, 6, 7, 8, 9, 10, 11, 14], 1, false), Op::Call(183, vec![3, 15], 1, false), Op::Call(209, vec![13, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_216() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(214, vec![3, 5], 1, false), Op::Call(213, vec![2, 6], 1, false), Op::Call(299, vec![2], 1, false), Op::Call(209, vec![8, 7], 1, false), Op::Call(173, vec![1, 9], 1, false), Op::Call(183, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![12, 25, 11]), Op::Store(vec![12, 24, 26]), Op::Store(vec![12, 23, 27]), Op::Store(vec![12, 22, 28]), Op::Store(vec![12, 21, 29]), Op::Store(vec![12, 20, 30]), Op::Store(vec![12, 16, 31]), Op::Store(vec![12, 19, 32]), Op::Store(vec![12, 18, 33]), Op::Store(vec![12, 17, 34]), Op::Store(vec![12, 16, 35]), Op::Store(vec![12, 15, 36]), Op::Store(vec![12, 14, 37]), Op::Store(vec![12, 13, 38]), Op::Call(177, vec![39, 5], 18, false), Op::Call(171, vec![48, 49, 50, 51, 52, 53, 54, 55, 5], 1, false), Op::Call(171, vec![40, 41, 42, 43, 44, 45, 46, 47, 58], 1, false), Op::Call(298, vec![56, 59], 1, false), Op::Call(177, vec![60, 5], 18, false), Op::Call(171, vec![69, 70, 71, 72, 73, 74, 75, 76, 5], 1, false), Op::Call(171, vec![61, 62, 63, 64, 65, 66, 67, 68, 79], 1, false), Op::Call(298, vec![77, 80], 1, false), Op::Const(G::from_u64(256)), Op::Mul(82, 41), Op::Const(G::from_u64(65536)), Op::Mul(84, 42), Op::Const(G::from_u64(16777216)), Op::Mul(86, 43), Op::Const(G::from_u64(4294967296)), Op::Mul(88, 44), Op::Const(G::from_u64(1099511627776)), Op::Mul(90, 45), Op::Const(G::from_u64(281474976710656)), Op::Mul(92, 46), Op::Const(G::from_u64(72057594037927936)), Op::Mul(94, 47), Op::Add(93, 95), Op::Add(91, 96), Op::Add(89, 97), Op::Add(87, 98), Op::Add(85, 99), Op::Add(83, 100), Op::Add(40, 101), Op::Mul(82, 49), Op::Mul(84, 50), Op::Mul(86, 51), Op::Mul(88, 52), Op::Mul(90, 53), Op::Mul(92, 54), Op::Mul(94, 55), Op::Add(108, 109), Op::Add(107, 110), Op::Add(106, 111), Op::Add(105, 112), Op::Add(104, 113), Op::Add(103, 114), Op::Add(48, 115), Op::Mul(82, 62), Op::Mul(84, 63), Op::Mul(86, 64), Op::Mul(88, 65), Op::Mul(90, 66), Op::Mul(92, 67), Op::Mul(94, 68), Op::Add(122, 123), Op::Add(121, 124), Op::Add(120, 125), Op::Add(119, 126), Op::Add(118, 127), Op::Add(117, 128), Op::Add(61, 129), Op::Mul(82, 70), Op::Mul(84, 71), Op::Mul(86, 72), Op::Mul(88, 73), Op::Mul(90, 74), Op::Mul(92, 75), Op::Mul(94, 76), Op::Add(136, 137), Op::Add(135, 138), Op::Add(134, 139), Op::Add(133, 140), Op::Add(132, 141), Op::Add(131, 142), Op::Add(69, 143)], ctrl: Ctrl::Return(0, vec![102, 116, 130, 144, 81]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_217() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::U8RangeCheck(11, 12), Op::Const(G::from_u64(256)), Op::Mul(13, 6), Op::Const(G::from_u64(65536)), Op::Mul(15, 7), Op::Const(G::from_u64(16777216)), Op::Mul(17, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 12), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(5, 32), Op::AssertEq(vec![33], vec![1], None), Op::Const(G::from_u64(1020)), Op::Sub(12, 34), Op::Add(11, 35), Op::Add(10, 36), Op::Add(9, 37), Op::EqZero(38), Op::Add(7, 8), Op::Add(6, 40), Op::Add(5, 41), Op::EqZero(42), Op::Const(G::from_u64(1)), Op::Sub(44, 43), Op::Mul(39, 45), Op::Sub(44, 46), Op::AssertEq(vec![47], vec![44], None), Op::Call(180, vec![0, 5, 6, 7, 8, 9, 10, 11, 12], 1, false), Op::Call(181, vec![48, 2], 1, false), Op::Store(vec![44, 44, 44]), Op::Call(134, vec![4, 50], 1, false), Op::Call(298, vec![49, 51], 1, false), Op::Call(177, vec![52, 50], 18, false), Op::Call(181, vec![69, 3], 1, false), Op::Call(177, vec![71, 50], 18, false), Op::Mul(13, 54), Op::Mul(15, 55), Op::Mul(17, 56), Op::Mul(19, 57), Op::Mul(21, 58), Op::Mul(23, 59), Op::Mul(25, 60), Op::Add(95, 96), Op::Add(94, 97), Op::Add(93, 98), Op::Add(92, 99), Op::Add(91, 100), Op::Add(90, 101), Op::Add(53, 102), Op::Mul(13, 62), Op::Mul(15, 63), Op::Mul(17, 64), Op::Mul(19, 65), Op::Mul(21, 66), Op::Mul(23, 67), Op::Mul(25, 68), Op::Add(109, 110), Op::Add(108, 111), Op::Add(107, 112), Op::Add(106, 113), Op::Add(105, 114), Op::Add(104, 115), Op::Add(61, 116), Op::Mul(13, 73), Op::Mul(15, 74), Op::Mul(17, 75), Op::Mul(19, 76), Op::Mul(21, 77), Op::Mul(23, 78), Op::Mul(25, 79), Op::Add(123, 124), Op::Add(122, 125), Op::Add(121, 126), Op::Add(120, 127), Op::Add(119, 128), Op::Add(118, 129), Op::Add(72, 130), Op::Mul(13, 81), Op::Mul(15, 82), Op::Mul(17, 83), Op::Mul(19, 84), Op::Mul(21, 85), Op::Mul(23, 86), Op::Mul(25, 87), Op::Add(137, 138), Op::Add(136, 139), Op::Add(135, 140), Op::Add(134, 141), Op::Add(133, 142), Op::Add(132, 143), Op::Add(80, 144)], ctrl: Ctrl::Return(0, vec![103, 117, 131, 145, 88]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_218() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![3], vec![6], None), Op::Call(218, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_219() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21], vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22], None)], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(12, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![22], vec![23], None), Op::Call(219, vec![11, 21], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_220() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(219, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], None), Op::Call(220, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_221() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Load(32, 6), Op::Call(12, vec![8, 9, 10, 11, 12, 13, 14, 15, 40, 41, 42, 43, 44, 45, 46, 47], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![72], vec![73], None), Op::Call(12, vec![16, 17, 18, 19, 20, 21, 22, 23, 48, 49, 50, 51, 52, 53, 54, 55], 1, false), Op::AssertEq(vec![74], vec![73], None), Op::Call(12, vec![24, 25, 26, 27, 28, 29, 30, 31, 56, 57, 58, 59, 60, 61, 62, 63], 1, false), Op::AssertEq(vec![75], vec![73], None), Op::Call(12, vec![32, 33, 34, 35, 36, 37, 38, 39, 64, 65, 66, 67, 68, 69, 70, 71], 1, false), Op::AssertEq(vec![76], vec![73], None), Op::Call(221, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![77]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_222() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(222, vec![4], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_223() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(204, vec![5, 6, 8], 2, false), Op::Add(3, 18), Op::Add(4, 19), Op::Mul(20, 20), Op::Const(G::from_u64(7)), Op::Mul(21, 21), Op::Mul(23, 24), Op::Sub(22, 25), Op::UnconstrainedGInverse(26), Op::Mul(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Mul(26, 30), Op::Const(G::from_u64(0)), Op::AssertEq(vec![31], vec![32], None), Op::Mul(27, 30), Op::AssertEq(vec![33], vec![32], None), Op::Mul(20, 27), Op::Sub(32, 21), Op::Mul(35, 27), Op::Const(G::from_u64(256)), Op::Mul(37, 10), Op::Const(G::from_u64(65536)), Op::Mul(39, 11), Op::Const(G::from_u64(16777216)), Op::Mul(41, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(43, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(45, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(47, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(49, 16), Op::Add(48, 50), Op::Add(46, 51), Op::Add(44, 52), Op::Add(42, 53), Op::Add(40, 54), Op::Add(38, 55), Op::Add(9, 56), Op::Mul(34, 57), Op::Mul(36, 32), Op::Mul(23, 59), Op::Add(58, 60), Op::Mul(34, 32), Op::Mul(36, 57), Op::Add(62, 63), Op::Add(0, 61), Op::Add(1, 64), Op::Call(223, vec![65, 66, 17, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_224() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(28, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(29, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(30, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(31, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(32, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(33, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_225() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(224, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], None), Op::Call(225, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_226() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(226, vec![3], 1, false), Op::Add(2, 4)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_227() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![2], None), Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::Const(G::from_u64(256)), Op::Mul(11, 4), Op::Const(G::from_u64(65536)), Op::Mul(13, 5), Op::Const(G::from_u64(16777216)), Op::Mul(15, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(17, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(19, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(21, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(23, 10), Op::Add(22, 24), Op::Add(20, 25), Op::Add(18, 26), Op::Add(16, 27), Op::Add(14, 28), Op::Add(12, 29), Op::Add(3, 30), Op::AssertEq(vec![31], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(10, 32), Op::Add(9, 33), Op::Add(8, 34), Op::Add(7, 35), Op::EqZero(36), Op::Add(5, 6), Op::Add(4, 38), Op::Add(3, 39), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::Sub(42, 41), Op::Mul(37, 43), Op::Sub(42, 44), Op::AssertEq(vec![45], vec![42], None), Op::Add(9, 10), Op::Add(8, 46), Op::Add(7, 47), Op::Add(6, 48), Op::AssertEq(vec![49], vec![2], None), Op::Sub(5, 42), Op::Mul(5, 50), Op::AssertEq(vec![51], vec![2], None), Op::Add(3, 4), Op::Mul(5, 52), Op::AssertEq(vec![53], vec![2], None)], ctrl: Ctrl::Return(0, vec![42]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_228() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 20)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 30), Op::Const(G::from_u64(1)), Op::AssertEq(vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40], vec![41, 41, 41, 41, 41, 41, 41, 41, 41, 41], None)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 27, 28, 29]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_229() -> Function { + Function { body: Block { ops: vec![Op::U8LessThan(0, 1), Op::Sub(0, 1), Op::EqZero(4), Op::Mul(5, 2), Op::Add(3, 6)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_230() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(229, vec![0, 8, 16], 1, false), Op::Call(229, vec![1, 9, 17], 1, false), Op::Call(229, vec![2, 10, 18], 1, false), Op::Call(229, vec![3, 11, 19], 1, false), Op::Call(229, vec![4, 12, 20], 1, false), Op::Call(229, vec![5, 13, 21], 1, false), Op::Call(229, vec![6, 14, 22], 1, false), Op::Call(229, vec![7, 15, 23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_231() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(11, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(25, 6), Op::Const(G::from_u64(65536)), Op::Mul(27, 7), Op::Const(G::from_u64(16777216)), Op::Mul(29, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(31, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(33, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(35, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(37, 12), Op::Add(36, 38), Op::Add(34, 39), Op::Add(32, 40), Op::Add(30, 41), Op::Add(28, 42), Op::Add(26, 43), Op::Add(5, 44), Op::Const(G::from_u64(1)), Op::Add(45, 46), Op::Const(G::from_u64(0)), Op::AssertEq(vec![47], vec![48], None), Op::Mul(25, 17), Op::Mul(27, 18), Op::Mul(29, 19), Op::Mul(31, 20), Op::Mul(33, 21), Op::Mul(35, 22), Op::Mul(37, 23), Op::Add(54, 55), Op::Add(53, 56), Op::Add(52, 57), Op::Add(51, 58), Op::Add(50, 59), Op::Add(49, 60), Op::Add(16, 61), Op::AssertEq(vec![62], vec![46], None), Op::Call(228, vec![4], 24, false), Op::Call(228, vec![15], 24, false), Op::Mul(25, 64), Op::Mul(27, 65), Op::Mul(29, 66), Op::Mul(31, 67), Op::Mul(33, 68), Op::Mul(35, 69), Op::Mul(37, 70), Op::Add(116, 117), Op::Add(115, 118), Op::Add(114, 119), Op::Add(113, 120), Op::Add(112, 121), Op::Add(111, 122), Op::Add(63, 123), Op::Const(G::from_u64(16)), Op::AssertEq(vec![124], vec![125], None), Op::Mul(25, 88), Op::Mul(27, 89), Op::Mul(29, 90), Op::Mul(31, 91), Op::Mul(33, 92), Op::Mul(35, 93), Op::Mul(37, 94), Op::Add(131, 132), Op::Add(130, 133), Op::Add(129, 134), Op::Add(128, 135), Op::Add(127, 136), Op::Add(126, 137), Op::Add(87, 138), Op::AssertEq(vec![139], vec![125], None), Op::Mul(25, 72), Op::Mul(27, 73), Op::Mul(29, 74), Op::Mul(31, 75), Op::Mul(33, 76), Op::Mul(35, 77), Op::Mul(37, 78), Op::Add(145, 146), Op::Add(144, 147), Op::Add(143, 148), Op::Add(142, 149), Op::Add(141, 150), Op::Add(140, 151), Op::Add(71, 152), Op::Mul(25, 96), Op::Mul(27, 97), Op::Mul(29, 98), Op::Mul(31, 99), Op::Mul(33, 100), Op::Mul(35, 101), Op::Mul(37, 102), Op::Add(159, 160), Op::Add(158, 161), Op::Add(157, 162), Op::Add(156, 163), Op::Add(155, 164), Op::Add(154, 165), Op::Add(95, 166), Op::AssertEq(vec![167], vec![153], None), Op::Mul(25, 80), Op::Mul(27, 81), Op::Mul(29, 82), Op::Mul(31, 83), Op::Mul(33, 84), Op::Mul(35, 85), Op::Mul(37, 86), Op::Add(173, 174), Op::Add(172, 175), Op::Add(171, 176), Op::Add(170, 177), Op::Add(169, 178), Op::Add(168, 179), Op::Add(79, 180), Op::Mul(25, 104), Op::Mul(27, 105), Op::Mul(29, 106), Op::Mul(31, 107), Op::Mul(33, 108), Op::Mul(35, 109), Op::Mul(37, 110), Op::Add(187, 188), Op::Add(186, 189), Op::Add(185, 190), Op::Add(184, 191), Op::Add(183, 192), Op::Add(182, 193), Op::Add(103, 194), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(196, 197), Op::U8RangeCheck(198, 199), Op::U8RangeCheck(200, 201), Op::U8RangeCheck(202, 203), Op::Mul(25, 197), Op::Mul(27, 198), Op::Mul(29, 199), Op::Mul(31, 200), Op::Mul(33, 201), Op::Mul(35, 202), Op::Mul(37, 203), Op::Add(209, 210), Op::Add(208, 211), Op::Add(207, 212), Op::Add(206, 213), Op::Add(205, 214), Op::Add(204, 215), Op::Add(196, 216), Op::AssertEq(vec![217], vec![181], None), Op::Const(G::from_u64(1020)), Op::Sub(203, 218), Op::Add(202, 219), Op::Add(201, 220), Op::Add(200, 221), Op::EqZero(222), Op::Add(198, 199), Op::Add(197, 224), Op::Add(196, 225), Op::EqZero(226), Op::Sub(46, 227), Op::Mul(223, 228), Op::Sub(46, 229), Op::AssertEq(vec![230], vec![46], None), Op::UnconstrainedGToBytes(195), Op::U8RangeCheck(231, 232), Op::U8RangeCheck(233, 234), Op::U8RangeCheck(235, 236), Op::U8RangeCheck(237, 238), Op::Mul(25, 232), Op::Mul(27, 233), Op::Mul(29, 234), Op::Mul(31, 235), Op::Mul(33, 236), Op::Mul(35, 237), Op::Mul(37, 238), Op::Add(244, 245), Op::Add(243, 246), Op::Add(242, 247), Op::Add(241, 248), Op::Add(240, 249), Op::Add(239, 250), Op::Add(231, 251), Op::AssertEq(vec![252], vec![195], None), Op::Sub(238, 218), Op::Add(237, 253), Op::Add(236, 254), Op::Add(235, 255), Op::EqZero(256), Op::Add(233, 234), Op::Add(232, 258), Op::Add(231, 259), Op::EqZero(260), Op::Sub(46, 261), Op::Mul(257, 262), Op::Sub(46, 263), Op::AssertEq(vec![264], vec![46], None), Op::Call(230, vec![196, 197, 198, 199, 200, 201, 202, 203, 231, 232, 233, 234, 235, 236, 237, 238], 1, false), Op::AssertEq(vec![265], vec![46], None), Op::Sub(153, 1), Op::EqZero(266), Op::UnconstrainedGToBytes(153), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::U8RangeCheck(272, 273), Op::U8RangeCheck(274, 275), Op::Mul(25, 269), Op::Mul(27, 270), Op::Mul(29, 271), Op::Mul(31, 272), Op::Mul(33, 273), Op::Mul(35, 274), Op::Mul(37, 275), Op::Add(281, 282), Op::Add(280, 283), Op::Add(279, 284), Op::Add(278, 285), Op::Add(277, 286), Op::Add(276, 287), Op::Add(268, 288), Op::AssertEq(vec![289], vec![153], None), Op::Sub(275, 218), Op::Add(274, 290), Op::Add(273, 291), Op::Add(272, 292), Op::EqZero(293), Op::Add(270, 271), Op::Add(269, 295), Op::Add(268, 296), Op::EqZero(297), Op::Sub(46, 298), Op::Mul(294, 299), Op::Sub(46, 300), Op::AssertEq(vec![301], vec![46], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(302, 303), Op::U8RangeCheck(304, 305), Op::U8RangeCheck(306, 307), Op::U8RangeCheck(308, 309), Op::Mul(25, 303), Op::Mul(27, 304), Op::Mul(29, 305), Op::Mul(31, 306), Op::Mul(33, 307), Op::Mul(35, 308), Op::Mul(37, 309), Op::Add(315, 316), Op::Add(314, 317), Op::Add(313, 318), Op::Add(312, 319), Op::Add(311, 320), Op::Add(310, 321), Op::Add(302, 322), Op::AssertEq(vec![323], vec![1], None), Op::Sub(309, 218), Op::Add(308, 324), Op::Add(307, 325), Op::Add(306, 326), Op::EqZero(327), Op::Add(304, 305), Op::Add(303, 329), Op::Add(302, 330), Op::EqZero(331), Op::Sub(46, 332), Op::Mul(328, 333), Op::Sub(46, 334), Op::AssertEq(vec![335], vec![46], None), Op::Call(230, vec![268, 269, 270, 271, 272, 273, 274, 275, 302, 303, 304, 305, 306, 307, 308, 309], 1, false), Op::Sub(46, 336), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(338, 339), Op::U8RangeCheck(340, 341), Op::U8RangeCheck(342, 343), Op::U8RangeCheck(344, 345), Op::Mul(25, 339), Op::Mul(27, 340), Op::Mul(29, 341), Op::Mul(31, 342), Op::Mul(33, 343), Op::Mul(35, 344), Op::Mul(37, 345), Op::Add(351, 352), Op::Add(350, 353), Op::Add(349, 354), Op::Add(348, 355), Op::Add(347, 356), Op::Add(346, 357), Op::Add(338, 358), Op::AssertEq(vec![359], vec![2], None), Op::Sub(345, 218), Op::Add(344, 360), Op::Add(343, 361), Op::Add(342, 362), Op::EqZero(363), Op::Add(340, 341), Op::Add(339, 365), Op::Add(338, 366), Op::EqZero(367), Op::Sub(46, 368), Op::Mul(364, 369), Op::Sub(46, 370), Op::AssertEq(vec![371], vec![46], None), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(372, 373), Op::U8RangeCheck(374, 375), Op::U8RangeCheck(376, 377), Op::U8RangeCheck(378, 379), Op::Mul(25, 373), Op::Mul(27, 374), Op::Mul(29, 375), Op::Mul(31, 376), Op::Mul(33, 377), Op::Mul(35, 378), Op::Mul(37, 379), Op::Add(385, 386), Op::Add(384, 387), Op::Add(383, 388), Op::Add(382, 389), Op::Add(381, 390), Op::Add(380, 391), Op::Add(372, 392), Op::AssertEq(vec![393], vec![181], None), Op::Sub(379, 218), Op::Add(378, 394), Op::Add(377, 395), Op::Add(376, 396), Op::EqZero(397), Op::Add(374, 375), Op::Add(373, 399), Op::Add(372, 400), Op::EqZero(401), Op::Sub(46, 402), Op::Mul(398, 403), Op::Sub(46, 404), Op::AssertEq(vec![405], vec![46], None), Op::Call(230, vec![338, 339, 340, 341, 342, 343, 344, 345, 372, 373, 374, 375, 376, 377, 378, 379], 1, false), Op::Mul(267, 406), Op::Add(337, 407), Op::AssertEq(vec![408], vec![46], None), Op::Call(231, vec![24, 153, 195], 1, false)], ctrl: Ctrl::Return(1, vec![409]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_232() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![46], None), Op::AssertEq(vec![2], vec![46], None), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![47], None)], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(17, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(297, vec![21], 1, false), Op::EqZero(48), Op::Const(G::from_u64(0)), Op::AssertEq(vec![49], vec![50], None), Op::Call(296, vec![39], 1, false), Op::AssertEq(vec![51], vec![48], None), Op::Call(296, vec![40], 1, false), Op::AssertEq(vec![52], vec![48], None), Op::Call(296, vec![36], 1, false), Op::AssertEq(vec![53], vec![48], None), Op::Call(206, vec![17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![54], vec![55], None), Op::Call(296, vec![17], 1, false), Op::Call(302, vec![8], 1, false), Op::Sub(56, 57), Op::EqZero(58), Op::AssertEq(vec![59], vec![55], None), Op::Call(207, vec![8, 17], 1, false), Op::Call(208, vec![11, 17], 1, false), Op::Call(302, vec![60], 1, false), Op::Call(297, vec![21], 1, false), Op::Sub(62, 63), Op::EqZero(64), Op::AssertEq(vec![65], vec![55], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![12, 17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![66], vec![67], None), Op::Call(221, vec![13, 18], 1, false), Op::AssertEq(vec![68], vec![67], None), Op::Call(218, vec![14, 22], 1, false), Op::AssertEq(vec![69], vec![67], None), Op::Call(225, vec![22], 1, false), Op::AssertEq(vec![70], vec![67], None), Op::Call(226, vec![17], 1, false), Op::Call(296, vec![22], 1, false), Op::AssertEq(vec![71], vec![72], None)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![73, 73, 73])], ctrl: Ctrl::Yield(0, vec![74]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(217, vec![41, 16, 19, 20, 21], 5, false), Op::Const(G::from_u64(0)), Op::Call(205, vec![79, 79, 15, 42, 43, 44, 45], 2, false), Op::Call(203, vec![60, 61, 22, 21, 39, 40, 37, 38, 36, 79, 80, 81, 42, 43, 44, 45, 74, 75, 76, 77], 1, false), Op::Call(302, vec![60], 1, false)], ctrl: Ctrl::Match(23, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![23], 1, false), Op::Call(301, vec![24], 1, false), Op::Sub(85, 84), Op::EqZero(86), Op::Const(G::from_u64(1)), Op::AssertEq(vec![87], vec![88], None), Op::Call(297, vec![25], 1, false), Op::Const(G::from_u64(3)), Op::Call(145, vec![37, 38], 1, false), Op::Add(90, 91), Op::AssertEq(vec![89], vec![92], None), Op::Call(307, vec![26], 1, false), Op::Sub(93, 84), Op::EqZero(94), Op::AssertEq(vec![95], vec![88], None), Op::Call(297, vec![27], 1, false), Op::AssertEq(vec![96], vec![88], None), Op::Store(vec![88, 88, 88])], ctrl: Ctrl::MatchContinue(37, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![97]) }), (G::from_u64(1), Block { ops: vec![Op::Call(136, vec![38, 97], 1, false)], ctrl: Ctrl::Yield(3, vec![98]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(136, vec![36, 98], 1, false), Op::Call(136, vec![40, 99], 1, false), Op::Call(136, vec![39, 100], 1, false), Op::Call(298, vec![78, 101], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![103, 103, 103]), Op::Call(177, vec![102, 104], 18, false), Op::Const(G::from_u64(256)), Op::Mul(123, 106), Op::Const(G::from_u64(65536)), Op::Mul(125, 107), Op::Const(G::from_u64(16777216)), Op::Mul(127, 108), Op::Const(G::from_u64(4294967296)), Op::Mul(129, 109), Op::Const(G::from_u64(1099511627776)), Op::Mul(131, 110), Op::Const(G::from_u64(281474976710656)), Op::Mul(133, 111), Op::Const(G::from_u64(72057594037927936)), Op::Mul(135, 112), Op::Add(134, 136), Op::Add(132, 137), Op::Add(130, 138), Op::Add(128, 139), Op::Add(126, 140), Op::Add(124, 141), Op::Add(105, 142), Op::Mul(123, 114), Op::Mul(125, 115), Op::Mul(127, 116), Op::Mul(129, 117), Op::Mul(131, 118), Op::Mul(133, 119), Op::Mul(135, 120), Op::Add(149, 150), Op::Add(148, 151), Op::Add(147, 152), Op::Add(146, 153), Op::Add(145, 154), Op::Add(144, 155), Op::Add(113, 156), Op::Call(140, vec![121, 23, 24, 5], 2, false), Op::Call(134, vec![27, 104], 1, false), Op::Call(298, vec![159, 160], 1, false), Op::Call(138, vec![161, 23], 1, false), Op::Call(139, vec![162, 28, 29, 30, 31, 32, 33, 34, 35, 6], 2, false), Op::Add(84, 0), Op::Const(G::from_u64(33)), Op::U32LessThan(165, 166), Op::AssertEq(vec![167], vec![103], None), Op::Call(161, vec![163, 164, 4, 165], 1, false), Op::Call(165, vec![25, 168, 18, 19, 20, 73, 37, 38, 61, 22, 83, 0, 165], 1, false), Op::AssertEq(vec![169], vec![103], None), Op::Const(G::from_u64(0)), Op::Call(164, vec![25, 26, 170, 4], 1, false), Op::Call(160, vec![163, 164, 171, 143, 157, 39, 40, 36, 37, 38, 18, 19, 20, 73, 61, 22, 76, 77, 83, 0, 165, 158, 23, 27, 84], 1, false), Op::Call(168, vec![26, 23, 172, 168, 170, 165], 1, false), Op::AssertEq(vec![173], vec![103], None), Op::Call(222, vec![21], 2, false)], ctrl: Ctrl::Return(4, vec![174, 175]) })) }))) })) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_233() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Load(26, 13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53], vec![54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54], None)], ctrl: Ctrl::Return(0, vec![20, 21]) }), (G::from_u64(0), Block { ops: vec![Op::Load(26, 13)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Call(232, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 23, 24, 25, 26, 14, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(1)), Op::Add(14, 56), Op::Add(20, 54), Op::Add(21, 55), Op::Call(233, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 27, 53, 57, 15, 16, 17, 18, 19, 58, 59], 2, false)], ctrl: Ctrl::Return(1, vec![60, 61]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_234() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![6], 1, false), Op::Call(298, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_235() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(299, vec![12], 1, false), Op::Call(227, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None), Op::Call(295, vec![14], 1, false), Op::Call(299, vec![12], 1, false), Op::AssertEq(vec![18], vec![19], None), Op::Const(G::from_u64(0)), Op::Call(231, vec![13, 20, 20], 1, false), Op::AssertEq(vec![21], vec![17], None)], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22])], ctrl: Ctrl::Yield(0, vec![23]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(216, vec![7, 22, 12, 13], 5, false), Op::Const(G::from_u64(0)), Op::Call(223, vec![28, 28, 13, 23, 24, 25, 26], 2, false), Op::Call(233, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 28, 27, 23, 24, 25, 26, 29, 30], 2, false), Op::EqZero(31), Op::EqZero(32), Op::Mul(33, 34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(234, vec![12], 1, false)], ctrl: Ctrl::Return(2, vec![37]) })) }))) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_236() -> Function { + Function { body: Block { ops: vec![Op::Call(31, vec![12], 2, false), Op::Call(65, vec![16, 15], 2, false), Op::Call(31, vec![18], 2, false), Op::Call(68, vec![20, 19], 2, false), Op::Call(31, vec![22], 2, false), Op::Call(70, vec![24, 23], 2, false), Op::Add(12, 13), Op::AssertEq(vec![26], vec![27], None), Op::Call(235, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25], 1, false), Op::Call(220, vec![28, 14], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![29], vec![30], None)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 15, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_237() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(238, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_238() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(240, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(238, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_239() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(240, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_240() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(27, vec![0], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(240, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_241() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Store(vec![2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86, 89, 92, 95])], ctrl: Ctrl::Return(0, vec![97, 96]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_242() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(0)), Op::Store(vec![34, 33, 1]), Op::Store(vec![34, 32, 35]), Op::Store(vec![34, 31, 36]), Op::Store(vec![34, 30, 37]), Op::Store(vec![34, 29, 38]), Op::Store(vec![34, 28, 39]), Op::Store(vec![34, 27, 40]), Op::Store(vec![34, 26, 41]), Op::Store(vec![34, 25, 42]), Op::Store(vec![34, 24, 43]), Op::Store(vec![34, 23, 44]), Op::Store(vec![34, 22, 45]), Op::Store(vec![34, 21, 46]), Op::Store(vec![34, 20, 47]), Op::Store(vec![34, 19, 48]), Op::Store(vec![34, 18, 49]), Op::Store(vec![34, 17, 50]), Op::Store(vec![34, 16, 51]), Op::Store(vec![34, 15, 52]), Op::Store(vec![34, 14, 53]), Op::Store(vec![34, 13, 54]), Op::Store(vec![34, 12, 55]), Op::Store(vec![34, 11, 56]), Op::Store(vec![34, 10, 57]), Op::Store(vec![34, 9, 58]), Op::Store(vec![34, 8, 59]), Op::Store(vec![34, 7, 60]), Op::Store(vec![34, 6, 61]), Op::Store(vec![34, 5, 62]), Op::Store(vec![34, 4, 63]), Op::Store(vec![34, 3, 64]), Op::Store(vec![34, 2, 65])], ctrl: Ctrl::Return(0, vec![66]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 65, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_243() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(256)), Op::Mul(33, 2), Op::Const(G::from_u64(65536)), Op::Mul(35, 3), Op::Const(G::from_u64(16777216)), Op::Mul(37, 4), Op::Add(36, 38), Op::Add(34, 39), Op::Add(1, 40), Op::Mul(33, 6), Op::Mul(35, 7), Op::Mul(37, 8), Op::Add(43, 44), Op::Add(42, 45), Op::Add(5, 46), Op::Mul(33, 10), Op::Mul(35, 11), Op::Mul(37, 12), Op::Add(49, 50), Op::Add(48, 51), Op::Add(9, 52), Op::Mul(33, 14), Op::Mul(35, 15), Op::Mul(37, 16), Op::Add(55, 56), Op::Add(54, 57), Op::Add(13, 58), Op::Mul(33, 18), Op::Mul(35, 19), Op::Mul(37, 20), Op::Add(61, 62), Op::Add(60, 63), Op::Add(17, 64), Op::Mul(33, 22), Op::Mul(35, 23), Op::Mul(37, 24), Op::Add(67, 68), Op::Add(66, 69), Op::Add(21, 70), Op::Mul(33, 26), Op::Mul(35, 27), Op::Mul(37, 28), Op::Add(73, 74), Op::Add(72, 75), Op::Add(25, 76), Op::Mul(33, 30), Op::Mul(35, 31), Op::Mul(37, 32), Op::Add(79, 80), Op::Add(78, 81), Op::Add(29, 82)], ctrl: Ctrl::Return(0, vec![41, 47, 53, 59, 65, 71, 77, 83]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_244() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(242, vec![1, 3], 1, false), Op::Call(242, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 5]), Op::Call(75, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_245() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(242, vec![0, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 3]), Op::Call(75, vec![5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_246() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(0, 4), Op::Add(5, 1), Op::Mul(6, 4), Op::Add(7, 2), Op::Mul(8, 4), Op::Add(9, 3)], ctrl: Ctrl::Return(0, vec![10]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_247() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(256)), Op::Mul(2, 66), Op::Add(67, 3), Op::Mul(68, 66), Op::Add(69, 4), Op::Mul(70, 66), Op::Add(71, 5), Op::Mul(34, 66), Op::Add(73, 35), Op::Mul(74, 66), Op::Add(75, 36), Op::Mul(76, 66), Op::Add(77, 37), Op::Sub(72, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(6, 80), Op::Add(81, 7), Op::Mul(82, 80), Op::Add(83, 8), Op::Mul(84, 80), Op::Add(85, 9), Op::Mul(38, 80), Op::Add(87, 39), Op::Mul(88, 80), Op::Add(89, 40), Op::Mul(90, 80), Op::Add(91, 41), Op::Sub(86, 92)], ctrl: Ctrl::Match(93, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(10, 94), Op::Add(95, 11), Op::Mul(96, 94), Op::Add(97, 12), Op::Mul(98, 94), Op::Add(99, 13), Op::Mul(42, 94), Op::Add(101, 43), Op::Mul(102, 94), Op::Add(103, 44), Op::Mul(104, 94), Op::Add(105, 45), Op::Sub(100, 106)], ctrl: Ctrl::Match(107, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(14, 108), Op::Add(109, 15), Op::Mul(110, 108), Op::Add(111, 16), Op::Mul(112, 108), Op::Add(113, 17), Op::Mul(46, 108), Op::Add(115, 47), Op::Mul(116, 108), Op::Add(117, 48), Op::Mul(118, 108), Op::Add(119, 49), Op::Sub(114, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(18, 122), Op::Add(123, 19), Op::Mul(124, 122), Op::Add(125, 20), Op::Mul(126, 122), Op::Add(127, 21), Op::Mul(50, 122), Op::Add(129, 51), Op::Mul(130, 122), Op::Add(131, 52), Op::Mul(132, 122), Op::Add(133, 53), Op::Sub(128, 134)], ctrl: Ctrl::Match(135, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(22, 136), Op::Add(137, 23), Op::Mul(138, 136), Op::Add(139, 24), Op::Mul(140, 136), Op::Add(141, 25), Op::Mul(54, 136), Op::Add(143, 55), Op::Mul(144, 136), Op::Add(145, 56), Op::Mul(146, 136), Op::Add(147, 57), Op::Sub(142, 148)], ctrl: Ctrl::Match(149, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(26, 150), Op::Add(151, 27), Op::Mul(152, 150), Op::Add(153, 28), Op::Mul(154, 150), Op::Add(155, 29), Op::Mul(58, 150), Op::Add(157, 59), Op::Mul(158, 150), Op::Add(159, 60), Op::Mul(160, 150), Op::Add(161, 61), Op::Sub(156, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(30, 164), Op::Add(165, 31), Op::Mul(166, 164), Op::Add(167, 32), Op::Mul(168, 164), Op::Add(169, 33), Op::Mul(62, 164), Op::Add(171, 63), Op::Mul(172, 164), Op::Add(173, 64), Op::Mul(174, 164), Op::Add(175, 65), Op::Sub(170, 176)], ctrl: Ctrl::Match(177, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![178]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(170, 176)], ctrl: Ctrl::Match(178, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![179]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![179]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(156, 162)], ctrl: Ctrl::Match(164, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![165]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![165]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(142, 148)], ctrl: Ctrl::Match(150, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![151]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(6, vec![151]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(128, 134)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![137]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(8, vec![137]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(114, 120)], ctrl: Ctrl::Match(122, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(9, vec![123]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![123]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(100, 106)], ctrl: Ctrl::Match(108, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![109]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(12, vec![109]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(86, 92)], ctrl: Ctrl::Match(94, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![95]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(14, vec![95]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(72, 78)], ctrl: Ctrl::Match(80, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(15, vec![81]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(16, vec![81]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 17, auxiliaries: 73, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_248() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![2, 5], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("aggr: tree leaves are not strictly sorted".into())), Op::Call(248, vec![3], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_249() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(241, vec![2], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![5, 3, 7])], ctrl: Ctrl::Return(0, vec![8, 4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(1, vec![4, 2]) }), (G::from_u64(2), Block { ops: vec![Op::Call(249, vec![2], 2, false), Op::Call(249, vec![4], 2, false), Op::Call(298, vec![3, 5], 1, false)], ctrl: Ctrl::Return(2, vec![7, 6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_250() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(245, vec![2], 1, false), Op::Call(250, vec![3], 1, false), Op::Store(vec![4, 5, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_251() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]), Op::Call(244, vec![2, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 9, 11])], ctrl: Ctrl::Return(1, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(244, vec![2, 5], 1, false), Op::Call(251, vec![6], 1, false), Op::Store(vec![7, 8, 9])], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_252() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(251, vec![0], 1, false), Op::Call(252, vec![7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_253() -> Function { + Function { body: Block { ops: vec![Op::Call(250, vec![0], 1, false), Op::Call(252, vec![1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_254() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(5)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(3, vec![33, 34, 35], 1, true), Op::Call(87, vec![36], 2, false), Op::Const(G::from_u64(226)), Op::AssertEq(vec![37], vec![39], Some("aggr: tree has the wrong Ixon tag".into())), Op::Call(249, vec![38], 2, false), Op::Load(3, 41), Op::Const(G::from_u64(1)), Op::AssertEq(vec![42, 43, 44], vec![45, 45, 45], Some("aggr: trailing bytes after AssumptionTree".into())), Op::Call(304, vec![40], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![46], vec![47], Some("aggr: a present tree must contain at least one leaf".into())), Op::Call(248, vec![40], 0, false), Op::Call(253, vec![40], 1, false), Op::Call(2, vec![48, 0], 1, false), Op::AssertEq(vec![49], vec![45], Some("aggr: tree leaves do not reproduce the canonical root".into()))], ctrl: Ctrl::Return(0, vec![40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 46, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_255() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Call(254, vec![1], 1, false)], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_256() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0), Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], Some("aggr: set element mismatch".into())), Op::Call(256, vec![4, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_257() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0), Op::Load(3, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(256, vec![1, 2], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(256, vec![0, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(247, vec![4, 7], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![4, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: subject union mismatch".into())), Op::Call(257, vec![5, 1, 11], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(2, vec![4, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: subject union mismatch".into())), Op::Call(257, vec![5, 8, 11], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(2, vec![7, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: subject union mismatch".into())), Op::Call(257, vec![0, 8, 11], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_258() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0), Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8, 6, 0, 7]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8, 3, 4, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9, 3, 4, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![9, 3, 4, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![9, 6, 0, 7]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_259() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![3, 0], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(259, vec![0, 4], 2, false)], ctrl: Ctrl::Return(1, vec![6, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![6, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![6, 1]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_260() -> Function { + Function { body: Block { ops: vec![Op::Call(258, vec![0, 1], 4, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8, 9, 10], vec![11, 11, 11], Some("aggr: output has an extra assumption".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(259, vec![5, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(260, vec![6, 7, 9, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![5, 11], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: outstanding assumption mismatch".into())), Op::Call(260, vec![6, 7, 9, 12], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_261() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(2)), Op::U8LessThan(3, 5), Op::Const(G::from_u64(1)), Op::AssertEq(vec![6], vec![7], Some("aggr structural: path side must be 0 or 1".into())), Op::Call(241, vec![4], 2, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![Op::Call(244, vec![8, 0], 1, false)], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![0, 8], 1, false)], ctrl: Ctrl::Yield(2, vec![10]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(261, vec![10, 12, 9], 2, false)], ctrl: Ctrl::Return(3, vec![13, 14]) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_262() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Load(32, 0), Op::IOGetInfo(2, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Call(3, vec![2, 35, 36], 1, true), Op::Call(87, vec![37], 2, false), Op::Const(G::from_u64(2)), Op::U8LessThan(38, 40), Op::Const(G::from_u64(1)), Op::AssertEq(vec![41], vec![42], Some("aggr structural: discharge choice must be 0 or 1".into()))], ctrl: Ctrl::Match(38, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39), Op::Const(G::from_u64(1)), Op::AssertEq(vec![43, 44, 45], vec![46, 46, 46], Some("aggr structural: carried choice has trailing bytes".into())), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![39], 2, false), Op::Const(G::from_u64(65)), Op::U8LessThan(43, 45), Op::Const(G::from_u64(1)), Op::AssertEq(vec![46], vec![47], Some("aggr structural: Merkle path exceeds 64 steps".into())), Op::Call(245, vec![0], 1, false), Op::Call(261, vec![48, 43, 44], 2, false), Op::Load(3, 50), Op::AssertEq(vec![51, 52, 53], vec![47, 47, 47], Some("aggr structural: trailing bytes after Merkle path".into())), Op::Call(2, vec![49, 1], 1, false), Op::AssertEq(vec![54], vec![47], Some("aggr structural: assumption path does not reach subject root".into()))], ctrl: Ctrl::Return(1, vec![47]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_263() -> Function { + Function { body: Block { ops: vec![Op::Call(258, vec![0, 1], 4, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8, 9, 10], vec![11, 11, 11], Some("aggr structural: output has an extra assumption".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(262, vec![5, 2], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(263, vec![6, 7, 2, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![5, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("aggr structural: outstanding assumption mismatch".into())), Op::Call(263, vec![6, 7, 2, 11], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_264() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(241, vec![2], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_265() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Const(G::from_u64(229)), Op::AssertEq(vec![1], vec![3], Some("aggr: claim is not CheckEnv".into())), Op::Call(87, vec![2], 2, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![4], vec![6], Some("aggr: unsupported object format".into())), Op::Call(87, vec![5], 2, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![9], Some("aggr: wrong validator identity".into())), Op::Call(241, vec![8], 2, false), Op::Call(264, vec![11], 3, false), Op::Load(3, 14), Op::AssertEq(vec![15, 16, 17], vec![9, 9, 9], Some("aggr: trailing bytes after CheckEnv claim".into()))], ctrl: Ctrl::Return(0, vec![10, 12, 13]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_266() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(4)), Op::IOGetInfo(8, vec![0, 1, 2, 3, 4, 5, 6, 7]), Op::Call(3, vec![8, 9, 10], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![43, 43, 43]), Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45]), Op::Store(vec![12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Call(78, vec![11, 44, 45, 45, 46, 47, 48], 1, false), Op::Call(77, vec![49], 32, false), Op::Const(G::from_u64(256)), Op::Mul(82, 51), Op::Const(G::from_u64(65536)), Op::Mul(84, 52), Op::Const(G::from_u64(16777216)), Op::Mul(86, 53), Op::Add(85, 87), Op::Add(83, 88), Op::Add(50, 89), Op::Mul(82, 55), Op::Mul(84, 56), Op::Mul(86, 57), Op::Add(92, 93), Op::Add(91, 94), Op::Add(54, 95), Op::Mul(82, 59), Op::Mul(84, 60), Op::Mul(86, 61), Op::Add(98, 99), Op::Add(97, 100), Op::Add(58, 101), Op::Mul(82, 63), Op::Mul(84, 64), Op::Mul(86, 65), Op::Add(104, 105), Op::Add(103, 106), Op::Add(62, 107), Op::Mul(82, 67), Op::Mul(84, 68), Op::Mul(86, 69), Op::Add(110, 111), Op::Add(109, 112), Op::Add(66, 113), Op::Mul(82, 71), Op::Mul(84, 72), Op::Mul(86, 73), Op::Add(116, 117), Op::Add(115, 118), Op::Add(70, 119), Op::Mul(82, 75), Op::Mul(84, 76), Op::Mul(86, 77), Op::Add(122, 123), Op::Add(121, 124), Op::Add(74, 125), Op::Mul(82, 79), Op::Mul(84, 80), Op::Mul(86, 81), Op::Add(128, 129), Op::Add(127, 130), Op::Add(78, 131), Op::AssertEq(vec![90, 96, 102, 108, 114, 120, 126, 132], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("aggr: claim preimage digest mismatch".into()))], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 41, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_267() -> Function { + Function { body: Block { ops: vec![Op::Call(310, vec![0, 1], 8, false), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Const(G::from_u64(65536)), Op::Mul(12, 4), Op::Const(G::from_u64(16777216)), Op::Mul(14, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 9), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(2, 29)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_268() -> Function { + Function { body: Block { ops: vec![Op::Call(267, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Call(267, vec![0, 4], 1, false), Op::Const(G::from_u64(2)), Op::Add(1, 6), Op::Call(267, vec![0, 7], 1, false), Op::Const(G::from_u64(3)), Op::Add(1, 9), Op::Call(267, vec![0, 10], 1, false), Op::Const(G::from_u64(4)), Op::Add(1, 12), Op::Call(267, vec![0, 13], 1, false), Op::Const(G::from_u64(5)), Op::Add(1, 15), Op::Call(267, vec![0, 16], 1, false), Op::Const(G::from_u64(6)), Op::Add(1, 18), Op::Call(267, vec![0, 19], 1, false), Op::Const(G::from_u64(7)), Op::Add(1, 21), Op::Call(267, vec![0, 22], 1, false)], ctrl: Ctrl::Return(0, vec![2, 5, 8, 11, 14, 17, 20, 23]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_269() -> Function { + Function { body: Block { ops: vec![Op::AssertEq(vec![0], vec![8], None), Op::AssertEq(vec![1], vec![9], None), Op::AssertEq(vec![2], vec![10], None), Op::AssertEq(vec![3], vec![11], None), Op::AssertEq(vec![4], vec![12], None), Op::AssertEq(vec![5], vec![13], None), Op::AssertEq(vec![6], vec![14], None), Op::AssertEq(vec![7], vec![15], None)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_270() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4, 5, 6], vec![7, 7, 7], Some("aggr: child proof must expose exactly one claim".into()))], ctrl: Ctrl::Return(0, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_271() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::IOGetInfo(17, vec![0]), Op::Call(3, vec![17, 18, 19], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![17, 17, 17]), Op::Const(G::from_u64(0)), Op::Store(vec![53, 53, 53, 53, 53, 53, 53, 53]), Op::Store(vec![21, 22, 23, 24, 25, 26, 21, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17]), Op::Call(78, vec![20, 52, 53, 53, 54, 55, 56], 1, false), Op::Call(77, vec![57], 32, false), Op::Const(G::from_u64(256)), Op::Mul(90, 59), Op::Const(G::from_u64(65536)), Op::Mul(92, 60), Op::Const(G::from_u64(16777216)), Op::Mul(94, 61), Op::Add(93, 95), Op::Add(91, 96), Op::Add(58, 97), Op::Mul(90, 63), Op::Mul(92, 64), Op::Mul(94, 65), Op::Add(100, 101), Op::Add(99, 102), Op::Add(62, 103), Op::Mul(90, 67), Op::Mul(92, 68), Op::Mul(94, 69), Op::Add(106, 107), Op::Add(105, 108), Op::Add(66, 109), Op::Mul(90, 71), Op::Mul(92, 72), Op::Mul(94, 73), Op::Add(112, 113), Op::Add(111, 114), Op::Add(70, 115), Op::Mul(90, 75), Op::Mul(92, 76), Op::Mul(94, 77), Op::Add(118, 119), Op::Add(117, 120), Op::Add(74, 121), Op::Mul(90, 79), Op::Mul(92, 80), Op::Mul(94, 81), Op::Add(124, 125), Op::Add(123, 126), Op::Add(78, 127), Op::Mul(90, 83), Op::Mul(92, 84), Op::Mul(94, 85), Op::Add(130, 131), Op::Add(129, 132), Op::Add(82, 133), Op::Mul(90, 87), Op::Mul(92, 88), Op::Mul(94, 89), Op::Add(136, 137), Op::Add(135, 138), Op::Add(86, 139)], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Call(269, vec![98, 104, 110, 116, 122, 128, 134, 140, 1, 2, 3, 4, 5, 6, 7, 8], 0, false)], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(269, vec![98, 104, 110, 116, 122, 128, 134, 140, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(90, vec![20], 10, false), Op::Call(90, vec![150], 10, false), Op::Call(90, vec![160], 10, false), Op::Call(90, vec![170], 10, false), Op::Call(90, vec![180], 10, false), Op::Call(90, vec![190], 10, false), Op::Call(90, vec![200], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![212, 212, 212, 212, 212, 212, 212, 212, 212, 212]), Op::Store(vec![211, 202, 203, 204, 205, 206, 207, 208, 209, 213]), Op::Store(vec![211, 192, 193, 194, 195, 196, 197, 198, 199, 214]), Op::Store(vec![211, 182, 183, 184, 185, 186, 187, 188, 189, 215]), Op::Store(vec![211, 172, 173, 174, 175, 176, 177, 178, 179, 216]), Op::Store(vec![211, 162, 163, 164, 165, 166, 167, 168, 169, 217]), Op::Store(vec![211, 152, 153, 154, 155, 156, 157, 158, 159, 218]), Op::Store(vec![211, 142, 143, 144, 145, 146, 147, 148, 149, 219]), Op::Call(90, vec![210], 10, false), Op::Call(103, vec![230, 221], 3, false), Op::Call(104, vec![233], 3, false), Op::Call(105, vec![236, 221], 2, false), Op::Store(vec![211, 222, 223, 224, 225, 226, 227, 228, 229, 232]), Op::Call(306, vec![220, 239], 1, false), Op::Load(3, 238), Op::AssertEq(vec![241, 242, 243], vec![212, 212, 212], None)], ctrl: Ctrl::Return(2, vec![141, 151, 161, 171, 181, 191, 201, 240, 231, 234, 235, 237]) })) }, layout: FunctionLayout { input_size: 17, selectors: 3, auxiliaries: 143, lookups: 30 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_272() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(13, vec![12]), Op::Const(G::from_u64(2)), Op::IOGetInfo(16, vec![12]), Op::Call(3, vec![16, 17, 18], 1, true), Op::Call(28, vec![19], 2, false), Op::Call(238, vec![21, 20], 2, false), Op::Load(3, 23), Op::Const(G::from_u64(1)), Op::AssertEq(vec![24, 25, 26], vec![27, 27, 27], None), Op::Call(31, vec![14], 2, false), Op::Call(65, vec![29, 28], 2, false), Op::Call(31, vec![31], 2, false), Op::Call(68, vec![33, 32], 2, false), Op::Call(31, vec![35], 2, false), Op::Call(70, vec![37, 36], 2, false), Op::Add(14, 15), Op::AssertEq(vec![39], vec![40], None), Op::Call(235, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 30, 34, 38], 1, false), Op::Call(220, vec![41, 22], 1, false), Op::AssertEq(vec![42], vec![27], None), Op::AssertEq(vec![27], vec![27], None)], ctrl: Ctrl::Return(0, vec![22]) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 27, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_273() -> Function { + Function { body: Block { ops: vec![Op::Call(271, vec![0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 12, false), Op::Call(272, vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1], 1, false), Op::Call(270, vec![40], 1, false), Op::Const(G::from_u64(0)), Op::Call(267, vec![41, 42], 1, false), Op::AssertEq(vec![43], vec![42], Some("aggr: child has the wrong claim channel".into()))], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(301, vec![41], 1, false), Op::Const(G::from_u64(10)), Op::AssertEq(vec![44], vec![45], Some("aggr: IxVM child must expose a 10-word verify_claim claim".into())), Op::Const(G::from_u64(1)), Op::Call(267, vec![41, 46], 1, false), Op::AssertEq(vec![47], vec![18], Some("aggr: IxVM child has the wrong entrypoint".into())), Op::Const(G::from_u64(2)), Op::Call(268, vec![41, 48], 8, false)], ctrl: Ctrl::Return(0, vec![49, 50, 51, 52, 53, 54, 55, 56]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![41], 1, false), Op::Const(G::from_u64(18)), Op::AssertEq(vec![44], vec![45], Some("aggr: recursive child must expose an 18-word ix_aggr claim".into())), Op::Const(G::from_u64(1)), Op::Call(267, vec![41, 46], 1, false), Op::AssertEq(vec![47], vec![19], Some("aggr: recursive child has the wrong entrypoint".into())), Op::Const(G::from_u64(2)), Op::Call(268, vec![41, 48], 8, false), Op::Call(269, vec![49, 50, 51, 52, 53, 54, 55, 56, 20, 21, 22, 23, 24, 25, 26, 27], 0, false), Op::Const(G::from_u64(10)), Op::Call(268, vec![41, 57], 8, false)], ctrl: Ctrl::Return(1, vec![58, 59, 60, 61, 62, 63, 64, 65]) }))) }, layout: FunctionLayout { input_size: 28, selectors: 2, auxiliaries: 35, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_274() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(273, vec![0, 35, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], 8, false), Op::Call(269, vec![36, 37, 38, 39, 40, 41, 42, 43, 27, 28, 29, 30, 31, 32, 33, 34], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_275() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(273, vec![0, 36, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Const(G::from_u64(1)), Op::Call(273, vec![1, 45, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Call(266, vec![37, 38, 39, 40, 41, 42, 43, 44], 1, false), Op::Call(265, vec![54], 3, false), Op::Call(266, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Call(265, vec![58], 3, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(62, vec![62]), Op::Call(3, vec![62, 63, 64], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![45, 45, 45]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36]), Op::Store(vec![66, 67, 68, 69, 70, 71, 66, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96]), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45]), Op::Call(78, vec![65, 97, 36, 36, 98, 99, 100], 1, false), Op::Call(77, vec![101], 32, false), Op::Const(G::from_u64(256)), Op::Mul(134, 103), Op::Const(G::from_u64(65536)), Op::Mul(136, 104), Op::Const(G::from_u64(16777216)), Op::Mul(138, 105), Op::Add(137, 139), Op::Add(135, 140), Op::Add(102, 141), Op::Mul(134, 107), Op::Mul(136, 108), Op::Mul(138, 109), Op::Add(144, 145), Op::Add(143, 146), Op::Add(106, 147), Op::Mul(134, 111), Op::Mul(136, 112), Op::Mul(138, 113), Op::Add(150, 151), Op::Add(149, 152), Op::Add(110, 153), Op::Mul(134, 115), Op::Mul(136, 116), Op::Mul(138, 117), Op::Add(156, 157), Op::Add(155, 158), Op::Add(114, 159), Op::Mul(134, 119), Op::Mul(136, 120), Op::Mul(138, 121), Op::Add(162, 163), Op::Add(161, 164), Op::Add(118, 165), Op::Mul(134, 123), Op::Mul(136, 124), Op::Mul(138, 125), Op::Add(168, 169), Op::Add(167, 170), Op::Add(122, 171), Op::Mul(134, 127), Op::Mul(136, 128), Op::Mul(138, 129), Op::Add(174, 175), Op::Add(173, 176), Op::Add(126, 177), Op::Mul(134, 131), Op::Mul(136, 132), Op::Mul(138, 133), Op::Add(180, 181), Op::Add(179, 182), Op::Add(130, 183), Op::AssertEq(vec![142, 148, 154, 160, 166, 172, 178, 184], vec![28, 29, 30, 31, 32, 33, 34, 35], Some("aggr: output claim digest mismatch".into())), Op::Call(265, vec![65], 3, false), Op::Call(254, vec![55], 1, false), Op::Call(254, vec![59], 1, false), Op::Call(255, vec![56, 57], 1, false), Op::Call(255, vec![60, 61], 1, false), Op::Call(254, vec![185], 1, false), Op::Call(255, vec![186, 187], 1, false), Op::Call(257, vec![188, 189, 192], 0, false), Op::Call(260, vec![190, 191, 192, 193], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 36, selectors: 1, auxiliaries: 74, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_276() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(273, vec![0, 36, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Const(G::from_u64(1)), Op::Call(273, vec![1, 45, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 8, false), Op::Call(266, vec![37, 38, 39, 40, 41, 42, 43, 44], 1, false), Op::Call(265, vec![54], 3, false), Op::Call(266, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Call(265, vec![58], 3, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(62, vec![62]), Op::Call(3, vec![62, 63, 64], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![45, 45, 45]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36]), Op::Store(vec![66, 67, 68, 69, 70, 71, 66, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96]), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45]), Op::Call(78, vec![65, 97, 36, 36, 98, 99, 100], 1, false), Op::Call(77, vec![101], 32, false), Op::Const(G::from_u64(256)), Op::Mul(134, 103), Op::Const(G::from_u64(65536)), Op::Mul(136, 104), Op::Const(G::from_u64(16777216)), Op::Mul(138, 105), Op::Add(137, 139), Op::Add(135, 140), Op::Add(102, 141), Op::Mul(134, 107), Op::Mul(136, 108), Op::Mul(138, 109), Op::Add(144, 145), Op::Add(143, 146), Op::Add(106, 147), Op::Mul(134, 111), Op::Mul(136, 112), Op::Mul(138, 113), Op::Add(150, 151), Op::Add(149, 152), Op::Add(110, 153), Op::Mul(134, 115), Op::Mul(136, 116), Op::Mul(138, 117), Op::Add(156, 157), Op::Add(155, 158), Op::Add(114, 159), Op::Mul(134, 119), Op::Mul(136, 120), Op::Mul(138, 121), Op::Add(162, 163), Op::Add(161, 164), Op::Add(118, 165), Op::Mul(134, 123), Op::Mul(136, 124), Op::Mul(138, 125), Op::Add(168, 169), Op::Add(167, 170), Op::Add(122, 171), Op::Mul(134, 127), Op::Mul(136, 128), Op::Mul(138, 129), Op::Add(174, 175), Op::Add(173, 176), Op::Add(126, 177), Op::Mul(134, 131), Op::Mul(136, 132), Op::Mul(138, 133), Op::Add(180, 181), Op::Add(179, 182), Op::Add(130, 183), Op::AssertEq(vec![142, 148, 154, 160, 166, 172, 178, 184], vec![28, 29, 30, 31, 32, 33, 34, 35], Some("aggr structural: output claim digest mismatch".into())), Op::Call(265, vec![65], 3, false), Op::Call(244, vec![55, 59], 1, false), Op::Call(2, vec![185, 188], 1, false), Op::AssertEq(vec![189], vec![45], Some("aggr structural: output subject root is not nodeHash(left, right)".into())), Op::Call(255, vec![56, 57], 1, false), Op::Call(255, vec![60, 61], 1, false), Op::Call(255, vec![186, 187], 1, false), Op::Call(263, vec![190, 191, 185, 192], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 36, selectors: 1, auxiliaries: 73, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_277() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Const(G::from_u64(82)), Op::AssertEq(vec![1], vec![3], Some("aggr range: statement has the wrong tag".into())), Op::Call(241, vec![2], 2, false), Op::Call(26, vec![5], 2, false), Op::Call(26, vec![7], 2, false), Op::Call(26, vec![9], 2, false), Op::Call(26, vec![11], 2, false), Op::Call(26, vec![13], 2, false), Op::Call(26, vec![15], 2, false), Op::Call(26, vec![17], 2, false), Op::Call(26, vec![19], 2, false), Op::Call(26, vec![21], 2, false), Op::Call(26, vec![23], 2, false), Op::Call(26, vec![25], 2, false), Op::Call(26, vec![27], 2, false), Op::Call(26, vec![29], 2, false), Op::Call(26, vec![31], 2, false), Op::Call(26, vec![33], 2, false), Op::Call(26, vec![35], 2, false), Op::Call(26, vec![37], 2, false), Op::Call(26, vec![39], 2, false), Op::Call(26, vec![41], 2, false), Op::Call(26, vec![43], 2, false), Op::Call(26, vec![45], 2, false), Op::Call(26, vec![47], 2, false), Op::Call(26, vec![49], 2, false), Op::Call(26, vec![51], 2, false), Op::Call(26, vec![53], 2, false), Op::Call(26, vec![55], 2, false), Op::Call(26, vec![57], 2, false), Op::Call(26, vec![59], 2, false), Op::Call(26, vec![61], 2, false), Op::Call(26, vec![63], 2, false), Op::Call(26, vec![65], 2, false), Op::Call(26, vec![67], 2, false), Op::Load(3, 69), Op::Const(G::from_u64(1)), Op::AssertEq(vec![70, 71, 72], vec![73, 73, 73], Some("aggr range: trailing bytes after the statement".into())), Op::Const(G::from_u64(256)), Op::Mul(74, 40), Op::Const(G::from_u64(65536)), Op::Mul(76, 42), Op::Const(G::from_u64(16777216)), Op::Mul(78, 44), Op::Const(G::from_u64(4294967296)), Op::Mul(80, 46), Op::Const(G::from_u64(1099511627776)), Op::Mul(82, 48), Op::Const(G::from_u64(281474976710656)), Op::Mul(84, 50), Op::Const(G::from_u64(72057594037927936)), Op::Mul(86, 52), Op::Add(85, 87), Op::Add(83, 88), Op::Add(81, 89), Op::Add(79, 90), Op::Add(77, 91), Op::Add(75, 92), Op::Add(38, 93), Op::Mul(74, 56), Op::Mul(76, 58), Op::Mul(78, 60), Op::Mul(80, 62), Op::Mul(82, 64), Op::Mul(84, 66), Op::Mul(86, 68), Op::Add(100, 101), Op::Add(99, 102), Op::Add(98, 103), Op::Add(97, 104), Op::Add(96, 105), Op::Add(95, 106), Op::Add(54, 107)], ctrl: Ctrl::Return(0, vec![4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 94, 108]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 72, lookups: 36 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_278() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(26, vec![2], 2, false), Op::Call(26, vec![4], 2, false), Op::Call(26, vec![6], 2, false), Op::Call(26, vec![8], 2, false), Op::Call(26, vec![10], 2, false), Op::Call(26, vec![12], 2, false), Op::Call(26, vec![14], 2, false), Op::Call(26, vec![16], 2, false), Op::Call(26, vec![18], 2, false), Op::Call(26, vec![20], 2, false), Op::Call(26, vec![22], 2, false), Op::Call(26, vec![24], 2, false), Op::Call(26, vec![26], 2, false), Op::Call(26, vec![28], 2, false), Op::Call(26, vec![30], 2, false), Op::Call(26, vec![32], 2, false), Op::Call(26, vec![34], 2, false), Op::Call(26, vec![36], 2, false), Op::Call(26, vec![38], 2, false), Op::Call(26, vec![40], 2, false), Op::Call(26, vec![42], 2, false), Op::Call(26, vec![44], 2, false), Op::Call(26, vec![46], 2, false), Op::Call(26, vec![48], 2, false), Op::Call(26, vec![50], 2, false), Op::Call(26, vec![52], 2, false), Op::Call(26, vec![54], 2, false), Op::Call(26, vec![56], 2, false), Op::Call(26, vec![58], 2, false), Op::Call(26, vec![60], 2, false), Op::Call(26, vec![62], 2, false), Op::Store(vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63])], ctrl: Ctrl::Return(0, vec![65, 64]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 66, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_279() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(278, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(279, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_280() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(280, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_281() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 9, false), Op::Call(14, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(280, vec![9, 10], 2, false), Op::Call(27, vec![12], 9, false), Op::Call(14, vec![13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(279, vec![21, 22], 2, false), Op::Call(27, vec![24], 9, false), Op::Call(14, vec![25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(280, vec![33, 34], 2, false), Op::Call(28, vec![36], 2, false), Op::Call(238, vec![38, 37], 2, false)], ctrl: Ctrl::Return(0, vec![11, 23, 35, 39, 40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_282() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(281, vec![0], 5, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(282, vec![6, 8], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 9])], ctrl: Ctrl::Return(1, vec![12, 10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_283() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(240, vec![2, 1], 2, false), Op::Call(26, vec![4], 2, false), Op::Call(26, vec![6], 2, false), Op::Call(26, vec![8], 2, false), Op::Call(26, vec![10], 2, false), Op::Call(26, vec![12], 2, false), Op::Call(26, vec![14], 2, false), Op::Call(26, vec![16], 2, false), Op::Call(26, vec![18], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 7, 9, 11, 13, 15, 17, 19, 20]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_284() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![0], 10, false), Op::Const(G::from_u64(1)), Op::Sub(1, 12), Op::Call(284, vec![11, 13], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 14])], ctrl: Ctrl::Return(1, vec![17, 15]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_285() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(2, vec![0]), Op::Call(3, vec![2, 3, 4], 1, true), Op::Call(75, vec![5], 1, false), Op::Call(2, vec![6, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("aggr range: preamble does not hash to the statement's batch digest".into())), Op::Call(27, vec![5], 9, false), Op::Call(14, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(282, vec![17, 18], 2, false), Op::Call(27, vec![20], 9, false), Op::Call(14, vec![21, 22, 23, 24, 25, 26, 27, 28], 1, false), Op::Call(284, vec![29, 30], 2, false), Op::Load(3, 32), Op::AssertEq(vec![33, 34, 35], vec![8, 8, 8], Some("aggr range: trailing bytes after the preamble".into()))], ctrl: Ctrl::Return(0, vec![19, 31]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 33, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_286() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Yield(0, vec![15]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(216, vec![7, 14, 12, 13], 5, false)], ctrl: Ctrl::Return(2, vec![15, 16, 17, 18, 19]) })) }))) }, layout: FunctionLayout { input_size: 14, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_287() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![21, 22, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Call(62, vec![13], 25, false), Op::Call(232, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 24, 25, 26, 27, 14, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 16, 17, 18, 19, 20], 2, false), Op::Const(G::from_u64(1)), Op::Add(14, 56), Op::Sub(15, 56), Op::Add(21, 54), Op::Add(22, 55), Op::Call(287, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 28, 53, 57, 58, 16, 17, 18, 19, 20, 59, 60], 3, false)], ctrl: Ctrl::Return(1, vec![61, 62, 63]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 23, selectors: 2, auxiliaries: 38, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_288() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::IOGetInfo(8, vec![8]), Op::Call(3, vec![8, 9, 10], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![43, 43, 43]), Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45, 45, 45, 45, 45, 45]), Op::Store(vec![12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Call(78, vec![11, 44, 45, 45, 46, 47, 48], 1, false), Op::Call(77, vec![49], 32, false), Op::Const(G::from_u64(256)), Op::Mul(82, 51), Op::Const(G::from_u64(65536)), Op::Mul(84, 52), Op::Const(G::from_u64(16777216)), Op::Mul(86, 53), Op::Add(85, 87), Op::Add(83, 88), Op::Add(50, 89), Op::Mul(82, 55), Op::Mul(84, 56), Op::Mul(86, 57), Op::Add(92, 93), Op::Add(91, 94), Op::Add(54, 95), Op::Mul(82, 59), Op::Mul(84, 60), Op::Mul(86, 61), Op::Add(98, 99), Op::Add(97, 100), Op::Add(58, 101), Op::Mul(82, 63), Op::Mul(84, 64), Op::Mul(86, 65), Op::Add(104, 105), Op::Add(103, 106), Op::Add(62, 107), Op::Mul(82, 67), Op::Mul(84, 68), Op::Mul(86, 69), Op::Add(110, 111), Op::Add(109, 112), Op::Add(66, 113), Op::Mul(82, 71), Op::Mul(84, 72), Op::Mul(86, 73), Op::Add(116, 117), Op::Add(115, 118), Op::Add(70, 119), Op::Mul(82, 75), Op::Mul(84, 76), Op::Mul(86, 77), Op::Add(122, 123), Op::Add(121, 124), Op::Add(74, 125), Op::Mul(82, 79), Op::Mul(84, 80), Op::Mul(86, 81), Op::Add(128, 129), Op::Add(127, 130), Op::Add(78, 131), Op::AssertEq(vec![90, 96, 102, 108, 114, 120, 126, 132], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("aggr range: output statement digest mismatch".into())), Op::Call(277, vec![11], 19, false)], ctrl: Ctrl::Return(0, vec![133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 60, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_289() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(273, vec![27, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], 8, false), Op::Call(266, vec![28, 29, 30, 31, 32, 33, 34, 35], 1, false), Op::Call(277, vec![36], 19, false)], ctrl: Ctrl::Return(0, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]) }, layout: FunctionLayout { input_size: 27, selectors: 1, auxiliaries: 29, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_290() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(271, vec![24, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 12, false), Op::Call(288, vec![16, 17, 18, 19, 20, 21, 22, 23], 19, false), Op::Call(285, vec![24, 37], 2, false), Op::Call(286, vec![25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 56, 57], 5, false), Op::Call(230, vec![38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![63], vec![64], Some("aggr range: the range ends before it starts".into())), Op::Call(14, vec![38, 39, 40, 41, 42, 43, 44, 45], 1, false), Op::Call(14, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Sub(66, 65), Op::IOGetInfo(24, vec![64]), Op::Call(31, vec![68], 2, false), Op::AssertEq(vec![70], vec![67], Some("aggr range: proof count differs from the range".into())), Op::Call(309, vec![56, 65], 1, false), Op::Call(287, vec![25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 72, 71, 65, 67, 62, 58, 59, 60, 61, 24, 24], 3, false), Op::Add(68, 69), Op::AssertEq(vec![75], vec![76], Some("aggr range: trailing bytes after the proofs".into())), Op::Sub(73, 54), Op::EqZero(77), Op::Sub(74, 55), Op::EqZero(79), Op::Mul(78, 80), Op::AssertEq(vec![81], vec![64], Some("aggr range: residual sum differs from the statement".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 55, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_291() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(289, vec![34, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], 19, false), Op::Const(G::from_u64(1)), Op::Call(289, vec![54, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], 19, false), Op::Call(288, vec![26, 27, 28, 29, 30, 31, 32, 33], 19, false), Op::Call(2, vec![35, 55], 1, false), Op::AssertEq(vec![93], vec![54], Some("aggr range: children verify different batches".into())), Op::Call(2, vec![74, 35], 1, false), Op::AssertEq(vec![94], vec![54], Some("aggr range: output names a different batch than the children".into())), Op::Call(14, vec![44, 45, 46, 47, 48, 49, 50, 51], 1, false), Op::Call(14, vec![56, 57, 58, 59, 60, 61, 62, 63], 1, false), Op::AssertEq(vec![95], vec![96], Some("aggr range: children are not adjacent".into())), Op::Call(14, vec![75, 76, 77, 78, 79, 80, 81, 82], 1, false), Op::Call(14, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::AssertEq(vec![97], vec![98], Some("aggr range: output starts elsewhere than the left child".into())), Op::Call(14, vec![83, 84, 85, 86, 87, 88, 89, 90], 1, false), Op::Call(14, vec![64, 65, 66, 67, 68, 69, 70, 71], 1, false), Op::AssertEq(vec![99], vec![100], Some("aggr range: output ends elsewhere than the right child".into())), Op::Add(52, 72), Op::Add(53, 73), Op::Sub(101, 91), Op::EqZero(103), Op::Sub(102, 92), Op::EqZero(105), Op::Mul(104, 106), Op::AssertEq(vec![107], vec![54], Some("aggr range: output residual is not the children's sum".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 71, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_292() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(289, vec![34, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], 19, false), Op::Call(271, vec![34, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 12, false), Op::Const(G::from_u64(1)), Op::Call(285, vec![66, 35], 2, false), Op::Call(299, vec![67], 1, false), Op::Call(227, vec![69], 1, false), Op::AssertEq(vec![70], vec![66], None), Op::Call(14, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::AssertEq(vec![71], vec![34], Some("aggr range: root range does not start at shard 0".into())), Op::Call(14, vec![44, 45, 46, 47, 48, 49, 50, 51], 1, false), Op::AssertEq(vec![72], vec![69], Some("aggr range: root range does not end at the last shard".into())), Op::Call(231, vec![68, 34, 34], 1, false), Op::AssertEq(vec![73], vec![66], None), Op::Call(286, vec![54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 68], 5, false), Op::Call(223, vec![52, 53, 68, 74, 75, 76, 77], 2, false), Op::EqZero(79), Op::EqZero(80), Op::Mul(81, 82), Op::AssertEq(vec![83], vec![66], Some("aggr range: the batch does not balance".into())), Op::Call(234, vec![67], 1, false), Op::Call(270, vec![84], 1, false), Op::Call(301, vec![85], 1, false), Op::Const(G::from_u64(10)), Op::AssertEq(vec![86], vec![87], Some("aggr range: batch must carry a 10-word verify_claim claim".into())), Op::Call(267, vec![85, 34], 1, false), Op::AssertEq(vec![88], vec![34], Some("aggr range: batch claim has the wrong channel".into())), Op::Call(267, vec![85, 66], 1, false), Op::AssertEq(vec![89], vec![16], Some("aggr range: batch claim has the wrong entrypoint".into())), Op::Const(G::from_u64(2)), Op::Call(268, vec![85, 90], 8, false), Op::Call(269, vec![91, 92, 93, 94, 95, 96, 97, 98, 26, 27, 28, 29, 30, 31, 32, 33], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 64, lookups: 18 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_293() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::IOGetInfo(16, vec![17]), Op::Const(G::from_u64(80)), Op::AssertEq(vec![19], vec![20], Some("aggr: allowed blob must be exactly 80 bytes".into())), Op::Call(3, vec![16, 18, 19], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![53, 53, 53]), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17]), Op::Store(vec![22, 23, 24, 25, 26, 27, 22, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]), Op::Store(vec![53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53]), Op::Call(78, vec![21, 54, 17, 17, 55, 56, 57], 1, false), Op::Call(77, vec![58], 32, false), Op::Const(G::from_u64(256)), Op::Mul(91, 60), Op::Const(G::from_u64(65536)), Op::Mul(93, 61), Op::Const(G::from_u64(16777216)), Op::Mul(95, 62), Op::Add(94, 96), Op::Add(92, 97), Op::Add(59, 98), Op::Mul(91, 64), Op::Mul(93, 65), Op::Mul(95, 66), Op::Add(101, 102), Op::Add(100, 103), Op::Add(63, 104), Op::Mul(91, 68), Op::Mul(93, 69), Op::Mul(95, 70), Op::Add(107, 108), Op::Add(106, 109), Op::Add(67, 110), Op::Mul(91, 72), Op::Mul(93, 73), Op::Mul(95, 74), Op::Add(113, 114), Op::Add(112, 115), Op::Add(71, 116), Op::Mul(91, 76), Op::Mul(93, 77), Op::Mul(95, 78), Op::Add(119, 120), Op::Add(118, 121), Op::Add(75, 122), Op::Mul(91, 80), Op::Mul(93, 81), Op::Mul(95, 82), Op::Add(125, 126), Op::Add(124, 127), Op::Add(79, 128), Op::Mul(91, 84), Op::Mul(93, 85), Op::Mul(95, 86), Op::Add(131, 132), Op::Add(130, 133), Op::Add(83, 134), Op::Mul(91, 88), Op::Mul(93, 89), Op::Mul(95, 90), Op::Add(137, 138), Op::Add(136, 139), Op::Add(87, 140), Op::AssertEq(vec![99, 105, 111, 117, 123, 129, 135, 141], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("aggr: allowed blob digest mismatch".into())), Op::Call(241, vec![21], 2, false), Op::Call(26, vec![143], 2, false), Op::Call(26, vec![145], 2, false), Op::Call(26, vec![147], 2, false), Op::Call(26, vec![149], 2, false), Op::Call(26, vec![151], 2, false), Op::Call(26, vec![153], 2, false), Op::Call(26, vec![155], 2, false), Op::Call(26, vec![157], 2, false), Op::Call(241, vec![159], 2, false), Op::Call(26, vec![161], 2, false), Op::Call(26, vec![163], 2, false), Op::Call(26, vec![165], 2, false), Op::Call(26, vec![167], 2, false), Op::Call(26, vec![169], 2, false), Op::Call(26, vec![171], 2, false), Op::Call(26, vec![173], 2, false), Op::Call(26, vec![175], 2, false), Op::Load(3, 177), Op::AssertEq(vec![178, 179, 180], vec![53, 53, 53], Some("aggr: allowed blob must be exactly 80 bytes".into())), Op::Call(243, vec![142], 8, false), Op::Call(243, vec![160], 8, false), Op::Call(14, vec![144, 146, 148, 150, 152, 154, 156, 158], 1, false), Op::Call(14, vec![162, 164, 166, 168, 170, 172, 174, 176], 1, false), Op::Const(G::from_u64(6)), Op::IOGetInfo(199, vec![17]), Op::AssertEq(vec![201], vec![53], Some("aggr: shape hint must be exactly one byte".into())), Op::Call(3, vec![199, 200, 201], 1, true), Op::Call(87, vec![202], 2, false), Op::Load(3, 204), Op::AssertEq(vec![205, 206, 207], vec![53, 53, 53], Some("aggr: trailing bytes after shape hint".into()))], ctrl: Ctrl::Match(203, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(274, vec![208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(274, vec![208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(275, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(275, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(275, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(275, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(276, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(6, vec![]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(276, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(7, vec![]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(276, vec![208, 209, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(8, vec![]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(276, vec![208, 208, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(9, vec![]) }), (G::from_u64(10), Block { ops: vec![Op::Call(290, vec![181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(10, vec![]) }), (G::from_u64(11), Block { ops: vec![Op::Call(291, vec![181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(11, vec![]) }), (G::from_u64(12), Block { ops: vec![Op::Call(292, vec![181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(12, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 13, auxiliaries: 106, lookups: 33 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_294() -> Function { + Function { body: Block { ops: vec![Op::Call(308, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_295() -> Function { + Function { body: Block { ops: vec![Op::Load(26, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(0), Block { ops: vec![Op::Call(295, vec![26], 1, false), Op::Const(G::from_u64(1)), Op::Add(27, 28)], ctrl: Ctrl::Return(1, vec![29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_296() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(296, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 5)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_297() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(297, vec![4], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_298() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(298, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_299() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(299, vec![6], 1, false), Op::Const(G::from_u64(1)), Op::Add(7, 8)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_300() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(300, vec![7], 1, false), Op::Const(G::from_u64(1)), Op::Add(8, 9)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_301() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(301, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Add(11, 12)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_302() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(302, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::Add(12, 13)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_303() -> Function { + Function { body: Block { ops: vec![Op::Call(309, vec![0, 1], 1, false), Op::Load(6, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_304() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_305() -> Function { + Function { body: Block { ops: vec![Op::Call(311, vec![0, 1], 1, false), Op::Load(4, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_306() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(306, vec![11, 1], 1, false), Op::Store(vec![12, 3, 4, 5, 6, 7, 8, 9, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_307() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(307, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_308() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(308, vec![0, 3], 1, false), Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_309() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(309, vec![0, 3], 1, false), Op::Load(6, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_310() -> Function { + Function { body: Block { ops: vec![Op::Call(312, vec![0, 1], 1, false), Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7, 8, 9, 10, 11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_311() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(311, vec![0, 3], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_312() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(312, vec![0, 3], 1, false), Op::Load(10, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21(), expected_function_22(), expected_function_23(), expected_function_24(), expected_function_25(), expected_function_26(), expected_function_27(), expected_function_28(), expected_function_29(), expected_function_30(), expected_function_31(), expected_function_32(), expected_function_33(), expected_function_34(), expected_function_35(), expected_function_36(), expected_function_37(), expected_function_38(), expected_function_39(), expected_function_40(), expected_function_41(), expected_function_42(), expected_function_43(), expected_function_44(), expected_function_45(), expected_function_46(), expected_function_47(), expected_function_48(), expected_function_49(), expected_function_50(), expected_function_51(), expected_function_52(), expected_function_53(), expected_function_54(), expected_function_55(), expected_function_56(), expected_function_57(), expected_function_58(), expected_function_59(), expected_function_60(), expected_function_61(), expected_function_62(), expected_function_63(), expected_function_64(), expected_function_65(), expected_function_66(), expected_function_67(), expected_function_68(), expected_function_69(), expected_function_70(), expected_function_71(), expected_function_72(), expected_function_73(), expected_function_74(), expected_function_75(), expected_function_76(), expected_function_77(), expected_function_78(), expected_function_79(), expected_function_80(), expected_function_81(), expected_function_82(), expected_function_83(), expected_function_84(), expected_function_85(), expected_function_86(), expected_function_87(), expected_function_88(), expected_function_89(), expected_function_90(), expected_function_91(), expected_function_92(), expected_function_93(), expected_function_94(), expected_function_95(), expected_function_96(), expected_function_97(), expected_function_98(), expected_function_99(), expected_function_100(), expected_function_101(), expected_function_102(), expected_function_103(), expected_function_104(), expected_function_105(), expected_function_106(), expected_function_107(), expected_function_108(), expected_function_109(), expected_function_110(), expected_function_111(), expected_function_112(), expected_function_113(), expected_function_114(), expected_function_115(), expected_function_116(), expected_function_117(), expected_function_118(), expected_function_119(), expected_function_120(), expected_function_121(), expected_function_122(), expected_function_123(), expected_function_124(), expected_function_125(), expected_function_126(), expected_function_127(), expected_function_128(), expected_function_129(), expected_function_130(), expected_function_131(), expected_function_132(), expected_function_133(), expected_function_134(), expected_function_135(), expected_function_136(), expected_function_137(), expected_function_138(), expected_function_139(), expected_function_140(), expected_function_141(), expected_function_142(), expected_function_143(), expected_function_144(), expected_function_145(), expected_function_146(), expected_function_147(), expected_function_148(), expected_function_149(), expected_function_150(), expected_function_151(), expected_function_152(), expected_function_153(), expected_function_154(), expected_function_155(), expected_function_156(), expected_function_157(), expected_function_158(), expected_function_159(), expected_function_160(), expected_function_161(), expected_function_162(), expected_function_163(), expected_function_164(), expected_function_165(), expected_function_166(), expected_function_167(), expected_function_168(), expected_function_169(), expected_function_170(), expected_function_171(), expected_function_172(), expected_function_173(), expected_function_174(), expected_function_175(), expected_function_176(), expected_function_177(), expected_function_178(), expected_function_179(), expected_function_180(), expected_function_181(), expected_function_182(), expected_function_183(), expected_function_184(), expected_function_185(), expected_function_186(), expected_function_187(), expected_function_188(), expected_function_189(), expected_function_190(), expected_function_191(), expected_function_192(), expected_function_193(), expected_function_194(), expected_function_195(), expected_function_196(), expected_function_197(), expected_function_198(), expected_function_199(), expected_function_200(), expected_function_201(), expected_function_202(), expected_function_203(), expected_function_204(), expected_function_205(), expected_function_206(), expected_function_207(), expected_function_208(), expected_function_209(), expected_function_210(), expected_function_211(), expected_function_212(), expected_function_213(), expected_function_214(), expected_function_215(), expected_function_216(), expected_function_217(), expected_function_218(), expected_function_219(), expected_function_220(), expected_function_221(), expected_function_222(), expected_function_223(), expected_function_224(), expected_function_225(), expected_function_226(), expected_function_227(), expected_function_228(), expected_function_229(), expected_function_230(), expected_function_231(), expected_function_232(), expected_function_233(), expected_function_234(), expected_function_235(), expected_function_236(), expected_function_237(), expected_function_238(), expected_function_239(), expected_function_240(), expected_function_241(), expected_function_242(), expected_function_243(), expected_function_244(), expected_function_245(), expected_function_246(), expected_function_247(), expected_function_248(), expected_function_249(), expected_function_250(), expected_function_251(), expected_function_252(), expected_function_253(), expected_function_254(), expected_function_255(), expected_function_256(), expected_function_257(), expected_function_258(), expected_function_259(), expected_function_260(), expected_function_261(), expected_function_262(), expected_function_263(), expected_function_264(), expected_function_265(), expected_function_266(), expected_function_267(), expected_function_268(), expected_function_269(), expected_function_270(), expected_function_271(), expected_function_272(), expected_function_273(), expected_function_274(), expected_function_275(), expected_function_276(), expected_function_277(), expected_function_278(), expected_function_279(), expected_function_280(), expected_function_281(), expected_function_282(), expected_function_283(), expected_function_284(), expected_function_285(), expected_function_286(), expected_function_287(), expected_function_288(), expected_function_289(), expected_function_290(), expected_function_291(), expected_function_292(), expected_function_293(), expected_function_294(), expected_function_295(), expected_function_296(), expected_function_297(), expected_function_298(), expected_function_299(), expected_function_300(), expected_function_301(), expected_function_302(), expected_function_303(), expected_function_304(), expected_function_305(), expected_function_306(), expected_function_307(), expected_function_308(), expected_function_309(), expected_function_310(), expected_function_311(), expected_function_312()], memory_sizes: vec![3, 4, 5, 6, 7, 8, 10, 11, 26, 32, 34], circuits: vec![Circuit { members: vec![0, 4, 13, 14, 99, 122, 123, 124, 125, 167, 183, 191], layout: FunctionLayout { input_size: 8, selectors: 40, auxiliaries: 20, lookups: 7 } }, Circuit { members: vec![1, 2, 247, 254, 256, 257, 265, 266, 268, 269, 270, 273], layout: FunctionLayout { input_size: 28, selectors: 40, auxiliaries: 73, lookups: 10 } }, Circuit { members: vec![12], layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![26, 40, 91, 93, 100, 144, 185, 192, 206, 207, 208, 302], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 18, lookups: 6 } }, Circuit { members: vec![27, 76, 77, 92, 128, 139, 151, 160, 168, 176, 177, 180, 197], layout: FunctionLayout { input_size: 44, selectors: 26, auxiliaries: 137, lookups: 14 } }, Circuit { members: vec![28, 48, 56, 59, 61, 75, 111, 140, 158, 173, 179, 204, 240, 300, 306], layout: FunctionLayout { input_size: 9, selectors: 27, auxiliaries: 98, lookups: 32 } }, Circuit { members: vec![31, 309], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 3 } }, Circuit { members: vec![35, 45, 49, 108, 127, 141, 152, 154, 162, 163, 166, 178], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![36, 296], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![37], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![38, 46, 47, 80, 90, 113, 121, 130, 135, 136, 174, 298], layout: FunctionLayout { input_size: 2, selectors: 23, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![39, 195], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 23, lookups: 3 } }, Circuit { members: vec![41, 52, 105, 119, 131, 138, 142, 157, 161, 164, 181, 186, 188, 200, 307], layout: FunctionLayout { input_size: 8, selectors: 31, auxiliaries: 42, lookups: 9 } }, Circuit { members: vec![43, 97], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![62], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 } }, Circuit { members: vec![65], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 } }, Circuit { members: vec![68], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 } }, Circuit { members: vec![70], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 } }, Circuit { members: vec![78], layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![79, 81, 82, 103, 175, 203, 241, 242], layout: FunctionLayout { input_size: 20, selectors: 27, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![86], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![87], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![88], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![89], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![95, 104, 145, 153, 159, 165, 201, 205, 238, 243, 299], layout: FunctionLayout { input_size: 25, selectors: 38, auxiliaries: 46, lookups: 20 } }, Circuit { members: vec![96], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 } }, Circuit { members: vec![112, 190, 304], layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![114], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 } }, Circuit { members: vec![115, 126, 134], layout: FunctionLayout { input_size: 4, selectors: 10, auxiliaries: 34, lookups: 13 } }, Circuit { members: vec![116], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 } }, Circuit { members: vec![117], layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 } }, Circuit { members: vec![120, 129, 305, 311], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![133], layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 } }, Circuit { members: vec![143], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 } }, Circuit { members: vec![146], layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 } }, Circuit { members: vec![147, 148, 149, 150, 194, 196], layout: FunctionLayout { input_size: 19, selectors: 12, auxiliaries: 14, lookups: 7 } }, Circuit { members: vec![171], layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![193], layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 } }, Circuit { members: vec![209], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![210], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![211], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![212], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 } }, Circuit { members: vec![213], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![214], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![215], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 } }, Circuit { members: vec![216], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 } }, Circuit { members: vec![217], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 } }, Circuit { members: vec![218], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![219], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 } }, Circuit { members: vec![220], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![221], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 } }, Circuit { members: vec![222], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 } }, Circuit { members: vec![223], layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 } }, Circuit { members: vec![224], layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 } }, Circuit { members: vec![225], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![226], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![227], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 } }, Circuit { members: vec![228], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 } }, Circuit { members: vec![229], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![230], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![231], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 } }, Circuit { members: vec![232], layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 } }, Circuit { members: vec![233], layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 } }, Circuit { members: vec![234], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![235], layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 } }, Circuit { members: vec![244, 245, 248, 249, 250, 251, 252, 253, 255, 258, 259, 260, 264, 267, 310, 312], layout: FunctionLayout { input_size: 4, selectors: 37, auxiliaries: 13, lookups: 7 } }, Circuit { members: vec![261, 262, 263, 271, 272, 274, 275, 276], layout: FunctionLayout { input_size: 36, selectors: 16, auxiliaries: 143, lookups: 30 } }, Circuit { members: vec![277], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 72, lookups: 36 } }, Circuit { members: vec![278], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 66, lookups: 34 } }, Circuit { members: vec![279], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![280], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![281], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 12 } }, Circuit { members: vec![282], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 4 } }, Circuit { members: vec![283], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 11 } }, Circuit { members: vec![284], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 4 } }, Circuit { members: vec![285], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 33, lookups: 10 } }, Circuit { members: vec![286], layout: FunctionLayout { input_size: 14, selectors: 3, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![287], layout: FunctionLayout { input_size: 23, selectors: 2, auxiliaries: 38, lookups: 5 } }, Circuit { members: vec![288], layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 60, lookups: 8 } }, Circuit { members: vec![289], layout: FunctionLayout { input_size: 27, selectors: 1, auxiliaries: 29, lookups: 4 } }, Circuit { members: vec![290], layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 55, lookups: 11 } }, Circuit { members: vec![291], layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 71, lookups: 12 } }, Circuit { members: vec![292], layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 64, lookups: 18 } }, Circuit { members: vec![293], layout: FunctionLayout { input_size: 16, selectors: 13, auxiliaries: 106, lookups: 33 } }, Circuit { members: vec![294, 297, 308], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![295], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 } }, Circuit { members: vec![301], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![303], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [187, 28, 234, 211, 2, 117, 245, 27, 105, 215, 208, 29, 121, 223, 99, 160, 204, 146, 145, 61, 215, 153, 253, 154, 131, 64, 84, 54, 111, 142, 52, 188], complete: false, expected: expected_program, functions: &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_86, pack: pack_86, pack_typed: pack_86_typed, write: |seed, offsets, row| { write_86(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, output_size: 1, seed_words: 201, schema: &SCHEMA_117, pack: pack_117, pack_typed: pack_117_typed, write: |seed, offsets, row| { write_117(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_220, pack: pack_220, pack_typed: pack_220_typed, write: write_220 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 1, seed_words: 25, schema: &SCHEMA_230, pack: pack_230, pack_typed: pack_230_typed, write: |seed, offsets, row| { write_230(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +] }; diff --git a/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs b/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs new file mode 100644 index 000000000..db799b96a --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs @@ -0,0 +1,325 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_ix_aggr_contract() -> *const u8; + fn aiur_trace_ix_aggr_schema() -> *const u8; + pub(super) fn aiur_trace_ix_aggr_86(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ix_aggr_117(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ix_aggr_220(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ix_aggr_230(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([187, 28, 234, 211, 2, 117, 245, 27, 105, 215, 208, 29, 121, 223, 99, 160, 204, 146, 145, 61, 215, 153, 253, 154, 131, 64, 84, 54, 111, 142, 52, 188], aiur_trace_ix_aggr_contract, aiur_trace_ix_aggr_schema, &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_86), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_117), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_220), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ix_aggr_230), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +], &[3, 67, 68, 0, 9, 0, 0, 0, 0, 0, 0, 0, 17, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 18, 12, 0, 0, 12, 0, 0, 0, 8, 6, 15, 6, 24, 6, 43, 0, 8, 0, 10, 6, 8, 6, 8, 0, 0, 8, 0, 0, 0, 12, 0, 0, 14, 0, 6, 52, 0, 0, 20, 0, 0, 17, 0, 31, 0, 0, 0, 0, 40, 170, 137, 13, 194, 5, 146, 158, 0, 0, 0, 162, 5, 4, 6, 6, 10, 18, 11, 0, 43, 15, 8, 0, 12, 5, 0, 0, 69, 8, 8, 0, 0, 10, 0, 0, 100, 5, 7, 22, 22, 27, 201, 0, 43, 8, 6, 18, 18, 19, 15, 33, 9, 22, 8, 7, 13, 0, 27, 10, 8, 8, 0, 8, 17, 42, 8, 8, 21, 11, 3, 19, 17, 19, 20, 23, 22, 8, 6, 11, 0, 0, 16, 41, 54, 36, 10, 10, 11, 9, 30, 9, 11, 23, 0, 0, 18, 0, 43, 8, 76, 23, 23, 8, 20, 13, 6, 0, 15, 0, 6, 3, 0, 3, 0, 7, 5, 14, 24, 29, 9, 33, 81, 0, 0, 12, 2, 0, 94, 16, 15, 6, 19, 12, 4, 6, 10, 12, 11, 6, 19, 68, 48, 10, 25, 11, 78, 12, 23, 2, 7, 6, 2, 42, 4, 25, 78, 119, 59, 10, 32, 0, 0, 10, 0, 15, 99, 67, 34, 8, 6, 0, 67, 9, 9, 8, 12, 10, 4, 47, 4, 10, 15, 10, 9, 15, 11, 49, 14, 6, 16, 49, 11, 11, 17, 8, 159, 40, 62, 44, 110, 109, 73, 67, 8, 8, 42, 11, 22, 16, 35, 21, 60, 68, 56, 74, 100, 93, 122, 7, 29, 6, 7, 8, 9, 10, 13, 14, 10, 5, 8, 15, 8, 7, 10, 14, 8, 14], &[16, 528, 536, 0, 72, 0, 0, 0, 0, 0, 0, 0, 136, 72, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 112, 88, 0, 0, 96, 0, 0, 0, 56, 48, 112, 48, 184, 48, 336, 0, 56, 0, 72, 48, 56, 48, 56, 0, 0, 56, 0, 0, 0, 80, 0, 0, 96, 0, 48, 352, 0, 0, 136, 0, 0, 128, 0, 176, 0, 0, 0, 0, 296, 432, 840, 80, 848, 40, 416, 272, 0, 0, 0, 176, 32, 32, 40, 40, 64, 112, 88, 0, 312, 96, 48, 0, 72, 40, 0, 0, 304, 48, 48, 0, 0, 64, 0, 0, 120, 32, 40, 136, 128, 128, 544, 0, 312, 40, 40, 96, 112, 120, 72, 176, 56, 120, 48, 48, 96, 0, 192, 64, 48, 48, 0, 48, 120, 280, 64, 56, 144, 72, 24, 128, 112, 144, 144, 168, 160, 56, 32, 80, 0, 0, 120, 224, 336, 216, 56, 64, 64, 48, 160, 56, 64, 112, 0, 0, 112, 0, 312, 48, 464, 168, 168, 48, 104, 96, 40, 0, 104, 0, 48, 24, 0, 24, 0, 56, 40, 88, 192, 224, 72, 256, 632, 0, 0, 88, 16, 0, 616, 120, 104, 32, 120, 64, 32, 40, 64, 72, 64, 40, 128, 432, 344, 48, 160, 40, 552, 72, 168, 16, 32, 40, 16, 232, 24, 88, 576, 688, 320, 64, 184, 0, 0, 56, 0, 104, 440, 408, 272, 40, 32, 0, 528, 40, 56, 40, 56, 56, 24, 304, 24, 40, 56, 48, 40, 56, 64, 312, 48, 32, 48, 360, 88, 88, 136, 32, 784, 200, 432, 352, 776, 768, 416, 408, 48, 48, 272, 56, 136, 112, 200, 144, 344, 512, 440, 408, 736, 656, 784, 48, 152, 40, 48, 48, 64, 72, 96, 96, 72, 32, 56, 104, 48, 48, 72, 104, 56, 104]) }; diff --git a/crates/aiur/src/trace_codegen/programs/ixvm.rs b/crates/aiur/src/trace_codegen/programs/ixvm.rs new file mode 100644 index 000000000..d123626e7 --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ixvm.rs @@ -0,0 +1,5735 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_15(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_15_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn write_15(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let op_0 = Bytes2::add(&v_0, &v_8); let [v_16, v_17]: [G; 2] = [op_0.0, op_0.1]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); let op_1 = Bytes2::add(&v_1, &v_9); let [v_18, v_19]: [G; 2] = [op_1.0, op_1.1]; row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); let op_2 = Bytes2::add(&v_18, &v_17); let [v_20, v_21]: [G; 2] = [op_2.0, op_2.1]; row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); let [v_22]: [G; 1] = [v_19 + v_21]; let op_4 = Bytes2::add(&v_2, &v_10); let [v_23, v_24]: [G; 2] = [op_4.0, op_4.1]; row[offsets.auxiliaries + 4] = v_23.as_canonical_u64(); let op_5 = Bytes2::add(&v_23, &v_22); let [v_25, v_26]: [G; 2] = [op_5.0, op_5.1]; row[offsets.auxiliaries + 5] = v_25.as_canonical_u64(); let [v_27]: [G; 1] = [v_24 + v_26]; let op_7 = Bytes2::add(&v_3, &v_11); let [v_28, v_29]: [G; 2] = [op_7.0, op_7.1]; row[offsets.auxiliaries + 6] = v_28.as_canonical_u64(); let op_8 = Bytes2::add(&v_28, &v_27); let [v_30, v_31]: [G; 2] = [op_8.0, op_8.1]; row[offsets.auxiliaries + 7] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = [v_29 + v_31]; let op_10 = Bytes2::add(&v_4, &v_12); let [v_33, v_34]: [G; 2] = [op_10.0, op_10.1]; row[offsets.auxiliaries + 8] = v_33.as_canonical_u64(); let op_11 = Bytes2::add(&v_33, &v_32); let [v_35, v_36]: [G; 2] = [op_11.0, op_11.1]; row[offsets.auxiliaries + 9] = v_35.as_canonical_u64(); let [v_37]: [G; 1] = [v_34 + v_36]; let op_13 = Bytes2::add(&v_5, &v_13); let [v_38, v_39]: [G; 2] = [op_13.0, op_13.1]; row[offsets.auxiliaries + 10] = v_38.as_canonical_u64(); let op_14 = Bytes2::add(&v_38, &v_37); let [v_40, v_41]: [G; 2] = [op_14.0, op_14.1]; row[offsets.auxiliaries + 11] = v_40.as_canonical_u64(); let [v_42]: [G; 1] = [v_39 + v_41]; let op_16 = Bytes2::add(&v_6, &v_14); let [v_43, v_44]: [G; 2] = [op_16.0, op_16.1]; row[offsets.auxiliaries + 12] = v_43.as_canonical_u64(); let op_17 = Bytes2::add(&v_43, &v_42); let [v_45, v_46]: [G; 2] = [op_17.0, op_17.1]; row[offsets.auxiliaries + 13] = v_45.as_canonical_u64(); let [v_47]: [G; 1] = [v_44 + v_46]; let op_19 = Bytes2::add(&v_7, &v_15); let [v_48, v_49]: [G; 2] = [op_19.0, op_19.1]; row[offsets.auxiliaries + 14] = v_48.as_canonical_u64(); let op_20 = Bytes2::add(&v_48, &v_47); let [v_50, v_51]: [G; 2] = [op_20.0, op_20.1]; row[offsets.auxiliaries + 15] = v_50.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_15: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], bytes: 24 }; + +fn pack_24(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67]: [G; 34] = context.load::<34>(0, v_0)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); seed[68] = v_67.as_canonical_u64(); match v_34.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103]: [G; 34] = context.call::<34>(3, 24, &[v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_69])?; seed[69] = v_70.as_canonical_u64(); seed[70] = v_71.as_canonical_u64(); seed[71] = v_72.as_canonical_u64(); seed[72] = v_73.as_canonical_u64(); seed[73] = v_74.as_canonical_u64(); seed[74] = v_75.as_canonical_u64(); seed[75] = v_76.as_canonical_u64(); seed[76] = v_77.as_canonical_u64(); seed[77] = v_78.as_canonical_u64(); seed[78] = v_79.as_canonical_u64(); seed[79] = v_80.as_canonical_u64(); seed[80] = v_81.as_canonical_u64(); seed[81] = v_82.as_canonical_u64(); seed[82] = v_83.as_canonical_u64(); seed[83] = v_84.as_canonical_u64(); seed[84] = v_85.as_canonical_u64(); seed[85] = v_86.as_canonical_u64(); seed[86] = v_87.as_canonical_u64(); seed[87] = v_88.as_canonical_u64(); seed[88] = v_89.as_canonical_u64(); seed[89] = v_90.as_canonical_u64(); seed[90] = v_91.as_canonical_u64(); seed[91] = v_92.as_canonical_u64(); seed[92] = v_93.as_canonical_u64(); seed[93] = v_94.as_canonical_u64(); seed[94] = v_95.as_canonical_u64(); seed[95] = v_96.as_canonical_u64(); seed[96] = v_97.as_canonical_u64(); seed[97] = v_98.as_canonical_u64(); seed[98] = v_99.as_canonical_u64(); seed[99] = v_100.as_canonical_u64(); seed[100] = v_101.as_canonical_u64(); seed[101] = v_102.as_canonical_u64(); seed[102] = v_103.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_105]: [G; 1] = [G::from_u64(4)]; let [v_106]: [G; 1] = [G::from_u64(8)]; let [v_107]: [G; 1] = [G::from_u64(103)]; let [v_108]: [G; 1] = [G::from_u64(230)]; let [v_109]: [G; 1] = [G::from_u64(9)]; let [v_110]: [G; 1] = [G::from_u64(106)]; let [v_111]: [G; 1] = [G::from_u64(133)]; let [v_112]: [G; 1] = [G::from_u64(174)]; let [v_113]: [G; 1] = [G::from_u64(187)]; let [v_114]: [G; 1] = [G::from_u64(114)]; let [v_115]: [G; 1] = [G::from_u64(243)]; let [v_116]: [G; 1] = [G::from_u64(110)]; let [v_117]: [G; 1] = [G::from_u64(60)]; let [v_118]: [G; 1] = [G::from_u64(58)]; let [v_119]: [G; 1] = [G::from_u64(245)]; let [v_120]: [G; 1] = [G::from_u64(79)]; let [v_121]: [G; 1] = [G::from_u64(165)]; let [v_122]: [G; 1] = [G::from_u64(127)]; let [v_123]: [G; 1] = [G::from_u64(82)]; let [v_124]: [G; 1] = [G::from_u64(14)]; let [v_125]: [G; 1] = [G::from_u64(81)]; let [v_126]: [G; 1] = [G::from_u64(140)]; let [v_127]: [G; 1] = [G::from_u64(104)]; let [v_128]: [G; 1] = [G::from_u64(5)]; let [v_129]: [G; 1] = [G::from_u64(155)]; let [v_130]: [G; 1] = [G::from_u64(171)]; let [v_131]: [G; 1] = [G::from_u64(217)]; let [v_132]: [G; 1] = [G::from_u64(131)]; let [v_133]: [G; 1] = [G::from_u64(31)]; let [v_134]: [G; 1] = [G::from_u64(25)]; let [v_135]: [G; 1] = [G::from_u64(205)]; let [v_136]: [G; 1] = [G::from_u64(224)]; let [v_137]: [G; 1] = [G::from_u64(91)]; let [v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171]: [G; 34] = context.load::<34>(38, v_103)?; seed[103] = v_138.as_canonical_u64(); seed[104] = v_139.as_canonical_u64(); seed[105] = v_140.as_canonical_u64(); seed[106] = v_141.as_canonical_u64(); seed[107] = v_142.as_canonical_u64(); seed[108] = v_143.as_canonical_u64(); seed[109] = v_144.as_canonical_u64(); seed[110] = v_145.as_canonical_u64(); seed[111] = v_146.as_canonical_u64(); seed[112] = v_147.as_canonical_u64(); seed[113] = v_148.as_canonical_u64(); seed[114] = v_149.as_canonical_u64(); seed[115] = v_150.as_canonical_u64(); seed[116] = v_151.as_canonical_u64(); seed[117] = v_152.as_canonical_u64(); seed[118] = v_153.as_canonical_u64(); seed[119] = v_154.as_canonical_u64(); seed[120] = v_155.as_canonical_u64(); seed[121] = v_156.as_canonical_u64(); seed[122] = v_157.as_canonical_u64(); seed[123] = v_158.as_canonical_u64(); seed[124] = v_159.as_canonical_u64(); seed[125] = v_160.as_canonical_u64(); seed[126] = v_161.as_canonical_u64(); seed[127] = v_162.as_canonical_u64(); seed[128] = v_163.as_canonical_u64(); seed[129] = v_164.as_canonical_u64(); seed[130] = v_165.as_canonical_u64(); seed[131] = v_166.as_canonical_u64(); seed[132] = v_167.as_canonical_u64(); seed[133] = v_168.as_canonical_u64(); seed[134] = v_169.as_canonical_u64(); seed[135] = v_170.as_canonical_u64(); seed[136] = v_171.as_canonical_u64(); match v_138.as_canonical_u64() { 1u64 => { let [v_172]: [G; 1] = [v_106 * v_33]; let [v_173]: [G; 1] = [v_105 + v_172]; let [v_174]: [G; 1] = [G::from_u64(0)]; let [v_175]: [G; 1] = [G::from_u64(64)]; let [v_176]: [G; 1] = [G::from_u64(103)]; let [v_177]: [G; 1] = [G::from_u64(230)]; let [v_178]: [G; 1] = [G::from_u64(9)]; let [v_179]: [G; 1] = [G::from_u64(106)]; let [v_180]: [G; 1] = [G::from_u64(133)]; let [v_181]: [G; 1] = [G::from_u64(174)]; let [v_182]: [G; 1] = [G::from_u64(187)]; let [v_183]: [G; 1] = [G::from_u64(114)]; let [v_184]: [G; 1] = [G::from_u64(243)]; let [v_185]: [G; 1] = [G::from_u64(110)]; let [v_186]: [G; 1] = [G::from_u64(60)]; let [v_187]: [G; 1] = [G::from_u64(58)]; let [v_188]: [G; 1] = [G::from_u64(245)]; let [v_189]: [G; 1] = [G::from_u64(79)]; let [v_190]: [G; 1] = [G::from_u64(165)]; let [v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222]: [G; 32] = context.call::<32>(58, 34, &[v_174, v_107, v_108, v_109, v_110, v_111, v_112, v_107, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_176, v_177, v_178, v_179, v_180, v_181, v_176, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_175, v_174, v_174, v_174, v_173, v_174, v_174, v_174, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed[137] = v_191.as_canonical_u64(); seed[138] = v_192.as_canonical_u64(); seed[139] = v_193.as_canonical_u64(); seed[140] = v_194.as_canonical_u64(); seed[141] = v_195.as_canonical_u64(); seed[142] = v_196.as_canonical_u64(); seed[143] = v_197.as_canonical_u64(); seed[144] = v_198.as_canonical_u64(); seed[145] = v_199.as_canonical_u64(); seed[146] = v_200.as_canonical_u64(); seed[147] = v_201.as_canonical_u64(); seed[148] = v_202.as_canonical_u64(); seed[149] = v_203.as_canonical_u64(); seed[150] = v_204.as_canonical_u64(); seed[151] = v_205.as_canonical_u64(); seed[152] = v_206.as_canonical_u64(); seed[153] = v_207.as_canonical_u64(); seed[154] = v_208.as_canonical_u64(); seed[155] = v_209.as_canonical_u64(); seed[156] = v_210.as_canonical_u64(); seed[157] = v_211.as_canonical_u64(); seed[158] = v_212.as_canonical_u64(); seed[159] = v_213.as_canonical_u64(); seed[160] = v_214.as_canonical_u64(); seed[161] = v_215.as_canonical_u64(); seed[162] = v_216.as_canonical_u64(); seed[163] = v_217.as_canonical_u64(); seed[164] = v_218.as_canonical_u64(); seed[165] = v_219.as_canonical_u64(); seed[166] = v_220.as_canonical_u64(); seed[167] = v_221.as_canonical_u64(); seed[168] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = context.store(59, &[v_174, v_103, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222])?; seed[169] = v_223.as_canonical_u64(); Ok(()) }, _ => { let [v_224]: [G; 1] = [G::from_u64(0)]; let [v_225]: [G; 1] = [G::from_u64(64)]; let [v_226]: [G; 1] = [G::from_u64(103)]; let [v_227]: [G; 1] = [G::from_u64(230)]; let [v_228]: [G; 1] = [G::from_u64(9)]; let [v_229]: [G; 1] = [G::from_u64(106)]; let [v_230]: [G; 1] = [G::from_u64(133)]; let [v_231]: [G; 1] = [G::from_u64(174)]; let [v_232]: [G; 1] = [G::from_u64(187)]; let [v_233]: [G; 1] = [G::from_u64(114)]; let [v_234]: [G; 1] = [G::from_u64(243)]; let [v_235]: [G; 1] = [G::from_u64(110)]; let [v_236]: [G; 1] = [G::from_u64(60)]; let [v_237]: [G; 1] = [G::from_u64(58)]; let [v_238]: [G; 1] = [G::from_u64(245)]; let [v_239]: [G; 1] = [G::from_u64(79)]; let [v_240]: [G; 1] = [G::from_u64(165)]; let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.call::<32>(77, 34, &[v_224, v_107, v_108, v_109, v_110, v_111, v_112, v_107, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_226, v_227, v_228, v_229, v_230, v_231, v_226, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_225, v_224, v_224, v_224, v_105, v_224, v_224, v_224, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed[137] = v_241.as_canonical_u64(); seed[138] = v_242.as_canonical_u64(); seed[139] = v_243.as_canonical_u64(); seed[140] = v_244.as_canonical_u64(); seed[141] = v_245.as_canonical_u64(); seed[142] = v_246.as_canonical_u64(); seed[143] = v_247.as_canonical_u64(); seed[144] = v_248.as_canonical_u64(); seed[145] = v_249.as_canonical_u64(); seed[146] = v_250.as_canonical_u64(); seed[147] = v_251.as_canonical_u64(); seed[148] = v_252.as_canonical_u64(); seed[149] = v_253.as_canonical_u64(); seed[150] = v_254.as_canonical_u64(); seed[151] = v_255.as_canonical_u64(); seed[152] = v_256.as_canonical_u64(); seed[153] = v_257.as_canonical_u64(); seed[154] = v_258.as_canonical_u64(); seed[155] = v_259.as_canonical_u64(); seed[156] = v_260.as_canonical_u64(); seed[157] = v_261.as_canonical_u64(); seed[158] = v_262.as_canonical_u64(); seed[159] = v_263.as_canonical_u64(); seed[160] = v_264.as_canonical_u64(); seed[161] = v_265.as_canonical_u64(); seed[162] = v_266.as_canonical_u64(); seed[163] = v_267.as_canonical_u64(); seed[164] = v_268.as_canonical_u64(); seed[165] = v_269.as_canonical_u64(); seed[166] = v_270.as_canonical_u64(); seed[167] = v_271.as_canonical_u64(); seed[168] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = context.store(78, &[v_224, v_103, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272])?; seed[169] = v_273.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(24, v_70)) }, } }, _ => { Err(no_match(24, v_34)) }, } } + +fn pack_24_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67]: [G; 34] = context.load::<34>(0, v_0)?; seed.u8(328, v_34); seed.u32(284, v_35); seed.u8(329, v_36); seed.u8(330, v_37); seed.u8(331, v_38); seed.u8(332, v_39); seed.u8(333, v_40); seed.u8(334, v_41); seed.u8(335, v_42); seed.u8(336, v_43); seed.u8(337, v_44); seed.u8(338, v_45); seed.u8(339, v_46); seed.u8(340, v_47); seed.u8(341, v_48); seed.u8(342, v_49); seed.u8(343, v_50); seed.u8(344, v_51); seed.u8(345, v_52); seed.u8(346, v_53); seed.u8(347, v_54); seed.u8(348, v_55); seed.u8(349, v_56); seed.u8(350, v_57); seed.u8(351, v_58); seed.u8(352, v_59); seed.u8(353, v_60); seed.u8(354, v_61); seed.u8(355, v_62); seed.u8(356, v_63); seed.u8(357, v_64); seed.u8(358, v_65); seed.u8(359, v_66); seed.u8(360, v_67); match v_34.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103]: [G; 34] = context.call::<34>(3, 24, &[v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_69])?; seed.u8(361, v_70); seed.u8(362, v_71); seed.u8(363, v_72); seed.u8(364, v_73); seed.u8(365, v_74); seed.u8(366, v_75); seed.u8(367, v_76); seed.u8(368, v_77); seed.u8(369, v_78); seed.u8(370, v_79); seed.u8(371, v_80); seed.u8(372, v_81); seed.u8(373, v_82); seed.u8(374, v_83); seed.u8(375, v_84); seed.u8(376, v_85); seed.u8(377, v_86); seed.u8(378, v_87); seed.u8(379, v_88); seed.u8(380, v_89); seed.u8(381, v_90); seed.u8(382, v_91); seed.u8(383, v_92); seed.u8(384, v_93); seed.u8(385, v_94); seed.u8(386, v_95); seed.u8(387, v_96); seed.u8(388, v_97); seed.u8(389, v_98); seed.u8(390, v_99); seed.u8(391, v_100); seed.u8(392, v_101); seed.u8(393, v_102); seed.u32(288, v_103); match v_70.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_105]: [G; 1] = [G::from_u64(4)]; let [v_106]: [G; 1] = [G::from_u64(8)]; let [v_107]: [G; 1] = [G::from_u64(103)]; let [v_108]: [G; 1] = [G::from_u64(230)]; let [v_109]: [G; 1] = [G::from_u64(9)]; let [v_110]: [G; 1] = [G::from_u64(106)]; let [v_111]: [G; 1] = [G::from_u64(133)]; let [v_112]: [G; 1] = [G::from_u64(174)]; let [v_113]: [G; 1] = [G::from_u64(187)]; let [v_114]: [G; 1] = [G::from_u64(114)]; let [v_115]: [G; 1] = [G::from_u64(243)]; let [v_116]: [G; 1] = [G::from_u64(110)]; let [v_117]: [G; 1] = [G::from_u64(60)]; let [v_118]: [G; 1] = [G::from_u64(58)]; let [v_119]: [G; 1] = [G::from_u64(245)]; let [v_120]: [G; 1] = [G::from_u64(79)]; let [v_121]: [G; 1] = [G::from_u64(165)]; let [v_122]: [G; 1] = [G::from_u64(127)]; let [v_123]: [G; 1] = [G::from_u64(82)]; let [v_124]: [G; 1] = [G::from_u64(14)]; let [v_125]: [G; 1] = [G::from_u64(81)]; let [v_126]: [G; 1] = [G::from_u64(140)]; let [v_127]: [G; 1] = [G::from_u64(104)]; let [v_128]: [G; 1] = [G::from_u64(5)]; let [v_129]: [G; 1] = [G::from_u64(155)]; let [v_130]: [G; 1] = [G::from_u64(171)]; let [v_131]: [G; 1] = [G::from_u64(217)]; let [v_132]: [G; 1] = [G::from_u64(131)]; let [v_133]: [G; 1] = [G::from_u64(31)]; let [v_134]: [G; 1] = [G::from_u64(25)]; let [v_135]: [G; 1] = [G::from_u64(205)]; let [v_136]: [G; 1] = [G::from_u64(224)]; let [v_137]: [G; 1] = [G::from_u64(91)]; let [v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171]: [G; 34] = context.load::<34>(38, v_103)?; seed.u8(394, v_138); seed.full(16, v_139); seed.full(24, v_140); seed.full(32, v_141); seed.full(40, v_142); seed.full(48, v_143); seed.full(56, v_144); seed.full(64, v_145); seed.full(72, v_146); seed.full(80, v_147); seed.full(88, v_148); seed.full(96, v_149); seed.full(104, v_150); seed.full(112, v_151); seed.full(120, v_152); seed.full(128, v_153); seed.full(136, v_154); seed.full(144, v_155); seed.full(152, v_156); seed.full(160, v_157); seed.full(168, v_158); seed.full(176, v_159); seed.full(184, v_160); seed.full(192, v_161); seed.full(200, v_162); seed.full(208, v_163); seed.full(216, v_164); seed.full(224, v_165); seed.full(232, v_166); seed.full(240, v_167); seed.full(248, v_168); seed.full(256, v_169); seed.full(264, v_170); seed.full(272, v_171); match v_138.as_canonical_u64() { 1u64 => { let [v_172]: [G; 1] = [v_106 * v_33]; let [v_173]: [G; 1] = [v_105 + v_172]; let [v_174]: [G; 1] = [G::from_u64(0)]; let [v_175]: [G; 1] = [G::from_u64(64)]; let [v_176]: [G; 1] = [G::from_u64(103)]; let [v_177]: [G; 1] = [G::from_u64(230)]; let [v_178]: [G; 1] = [G::from_u64(9)]; let [v_179]: [G; 1] = [G::from_u64(106)]; let [v_180]: [G; 1] = [G::from_u64(133)]; let [v_181]: [G; 1] = [G::from_u64(174)]; let [v_182]: [G; 1] = [G::from_u64(187)]; let [v_183]: [G; 1] = [G::from_u64(114)]; let [v_184]: [G; 1] = [G::from_u64(243)]; let [v_185]: [G; 1] = [G::from_u64(110)]; let [v_186]: [G; 1] = [G::from_u64(60)]; let [v_187]: [G; 1] = [G::from_u64(58)]; let [v_188]: [G; 1] = [G::from_u64(245)]; let [v_189]: [G; 1] = [G::from_u64(79)]; let [v_190]: [G; 1] = [G::from_u64(165)]; let [v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222]: [G; 32] = context.call::<32>(58, 34, &[v_174, v_107, v_108, v_109, v_110, v_111, v_112, v_107, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_176, v_177, v_178, v_179, v_180, v_181, v_176, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_175, v_174, v_174, v_174, v_173, v_174, v_174, v_174, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed.u8(395, v_191); seed.u8(396, v_192); seed.u8(397, v_193); seed.u8(398, v_194); seed.u8(399, v_195); seed.u8(400, v_196); seed.u8(401, v_197); seed.u8(402, v_198); seed.u8(403, v_199); seed.u8(404, v_200); seed.u8(405, v_201); seed.u8(406, v_202); seed.u8(407, v_203); seed.u8(408, v_204); seed.u8(409, v_205); seed.u8(410, v_206); seed.u8(411, v_207); seed.u8(412, v_208); seed.u8(413, v_209); seed.u8(414, v_210); seed.u8(415, v_211); seed.u8(416, v_212); seed.u8(417, v_213); seed.u8(418, v_214); seed.u8(419, v_215); seed.u8(420, v_216); seed.u8(421, v_217); seed.u8(422, v_218); seed.u8(423, v_219); seed.u8(424, v_220); seed.u8(425, v_221); seed.u8(426, v_222); let [v_223]: [G; 1] = context.store(59, &[v_174, v_103, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222])?; seed.u32(292, v_223); Ok(()) }, _ => { let [v_224]: [G; 1] = [G::from_u64(0)]; let [v_225]: [G; 1] = [G::from_u64(64)]; let [v_226]: [G; 1] = [G::from_u64(103)]; let [v_227]: [G; 1] = [G::from_u64(230)]; let [v_228]: [G; 1] = [G::from_u64(9)]; let [v_229]: [G; 1] = [G::from_u64(106)]; let [v_230]: [G; 1] = [G::from_u64(133)]; let [v_231]: [G; 1] = [G::from_u64(174)]; let [v_232]: [G; 1] = [G::from_u64(187)]; let [v_233]: [G; 1] = [G::from_u64(114)]; let [v_234]: [G; 1] = [G::from_u64(243)]; let [v_235]: [G; 1] = [G::from_u64(110)]; let [v_236]: [G; 1] = [G::from_u64(60)]; let [v_237]: [G; 1] = [G::from_u64(58)]; let [v_238]: [G; 1] = [G::from_u64(245)]; let [v_239]: [G; 1] = [G::from_u64(79)]; let [v_240]: [G; 1] = [G::from_u64(165)]; let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.call::<32>(77, 34, &[v_224, v_107, v_108, v_109, v_110, v_111, v_112, v_107, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_226, v_227, v_228, v_229, v_230, v_231, v_226, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_225, v_224, v_224, v_224, v_105, v_224, v_224, v_224, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed.u8(395, v_241); seed.u8(396, v_242); seed.u8(397, v_243); seed.u8(398, v_244); seed.u8(399, v_245); seed.u8(400, v_246); seed.u8(401, v_247); seed.u8(402, v_248); seed.u8(403, v_249); seed.u8(404, v_250); seed.u8(405, v_251); seed.u8(406, v_252); seed.u8(407, v_253); seed.u8(408, v_254); seed.u8(409, v_255); seed.u8(410, v_256); seed.u8(411, v_257); seed.u8(412, v_258); seed.u8(413, v_259); seed.u8(414, v_260); seed.u8(415, v_261); seed.u8(416, v_262); seed.u8(417, v_263); seed.u8(418, v_264); seed.u8(419, v_265); seed.u8(420, v_266); seed.u8(421, v_267); seed.u8(422, v_268); seed.u8(423, v_269); seed.u8(424, v_270); seed.u8(425, v_271); seed.u8(426, v_272); let [v_273]: [G; 1] = context.store(78, &[v_224, v_103, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272])?; seed.u32(292, v_273); Ok(()) }, } }, _ => { Err(no_match(24, v_70)) }, } }, _ => { Err(no_match(24, v_34)) }, } } + +fn write_24(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67]: [G; 34] = [G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68])]; row[offsets.auxiliaries + 1] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_67.as_canonical_u64(); match v_34.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103]: [G; 34] = [G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102])]; row[offsets.auxiliaries + 35] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_103.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171]: [G; 34] = [G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136])]; row[offsets.auxiliaries + 69] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_171.as_canonical_u64(); match v_138.as_canonical_u64() { 1u64 => { let [v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222]: [G; 32] = [G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163]), G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166]), G::from_u64(seed[167]), G::from_u64(seed[168])]; row[offsets.auxiliaries + 103] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_193.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_198.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_199.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_213.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_215.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = [G::from_u64(seed[169])]; row[offsets.auxiliaries + 135] = v_223.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 103] = (v_138 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = [G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163]), G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166]), G::from_u64(seed[167]), G::from_u64(seed[168])]; row[offsets.auxiliaries + 104] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_264.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(seed[169])]; row[offsets.auxiliaries + 136] = v_273.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(24, v_70)) }, } }, _ => { Err(no_match(24, v_34)) }, } } + +static SCHEMA_24: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 280, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 8, 328, 284, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 288, 394, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 292], bytes: 432 }; + +fn pack_26(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.returned::<1>(1)?; seed[11] = v_10.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(3, &[v_11, v_8, v_1])?; seed[11] = v_12.as_canonical_u64(); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = context.returned::<1>(4)?; seed[12] = v_13.as_canonical_u64(); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(8)?; seed[12] = v_17.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(26, v_7)) }, } } + +fn pack_26_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(73, v_7); seed.full(32, v_8); seed.u32(68, v_9); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.returned::<1>(1)?; seed.full(40, v_10); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(3, &[v_11, v_8, v_1])?; seed.full(40, v_12); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = context.returned::<1>(4)?; seed.full(48, v_13); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(8)?; seed.full(48, v_17); Ok(()) }, } }, _ => { Err(no_match(26, v_7)) }, } } + +fn write_26(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); match v_2.as_canonical_u64() { 63u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 5] = (v_2 - G::from_u64(63)).inverse().as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 6] = v_17.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(26, v_7)) }, } } + +static SCHEMA_26: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 56, 8, 72, 16, 60, 64, 24, 73, 32, 68, 40, 48], bytes: 80 }; + +fn pack_27(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); seed[97] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed[131] = v_130.as_canonical_u64(); seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed[143] = v_142.as_canonical_u64(); seed[144] = v_143.as_canonical_u64(); seed[145] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed[146] = v_145.as_canonical_u64(); seed[147] = v_146.as_canonical_u64(); seed[148] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed[149] = v_148.as_canonical_u64(); seed[150] = v_149.as_canonical_u64(); seed[151] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed[152] = v_151.as_canonical_u64(); seed[153] = v_152.as_canonical_u64(); seed[154] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed[155] = v_154.as_canonical_u64(); seed[156] = v_155.as_canonical_u64(); seed[157] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed[158] = v_157.as_canonical_u64(); seed[159] = v_158.as_canonical_u64(); seed[160] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed[161] = v_160.as_canonical_u64(); seed[162] = v_161.as_canonical_u64(); seed[163] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed[164] = v_163.as_canonical_u64(); seed[165] = v_164.as_canonical_u64(); seed[166] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed[167] = v_166.as_canonical_u64(); seed[168] = v_167.as_canonical_u64(); seed[169] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed[170] = v_169.as_canonical_u64(); seed[171] = v_170.as_canonical_u64(); seed[172] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed[173] = v_172.as_canonical_u64(); seed[174] = v_173.as_canonical_u64(); seed[175] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed[176] = v_175.as_canonical_u64(); seed[177] = v_176.as_canonical_u64(); seed[178] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed[179] = v_178.as_canonical_u64(); seed[180] = v_179.as_canonical_u64(); seed[181] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed[182] = v_181.as_canonical_u64(); seed[183] = v_182.as_canonical_u64(); seed[184] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed[185] = v_184.as_canonical_u64(); seed[186] = v_185.as_canonical_u64(); seed[187] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed[188] = v_187.as_canonical_u64(); seed[189] = v_188.as_canonical_u64(); seed[190] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed[191] = v_190.as_canonical_u64(); seed[192] = v_191.as_canonical_u64(); seed[193] = v_192.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(27, v_187)) }, } }, _ => { Err(no_match(27, v_184)) }, } }, _ => { Err(no_match(27, v_181)) }, } }, _ => { Err(no_match(27, v_178)) }, } }, _ => { Err(no_match(27, v_175)) }, } }, _ => { Err(no_match(27, v_172)) }, } }, _ => { Err(no_match(27, v_169)) }, } }, _ => { Err(no_match(27, v_166)) }, } }, _ => { Err(no_match(27, v_163)) }, } }, _ => { Err(no_match(27, v_160)) }, } }, _ => { Err(no_match(27, v_157)) }, } }, _ => { Err(no_match(27, v_154)) }, } }, _ => { Err(no_match(27, v_151)) }, } }, _ => { Err(no_match(27, v_148)) }, } }, _ => { Err(no_match(27, v_145)) }, } }, _ => { Err(no_match(27, v_142)) }, } }, _ => { Err(no_match(27, v_139)) }, } }, _ => { Err(no_match(27, v_136)) }, } }, _ => { Err(no_match(27, v_133)) }, } }, _ => { Err(no_match(27, v_130)) }, } }, _ => { Err(no_match(27, v_127)) }, } }, _ => { Err(no_match(27, v_124)) }, } }, _ => { Err(no_match(27, v_121)) }, } }, _ => { Err(no_match(27, v_118)) }, } }, _ => { Err(no_match(27, v_115)) }, } }, _ => { Err(no_match(27, v_112)) }, } }, _ => { Err(no_match(27, v_109)) }, } }, _ => { Err(no_match(27, v_106)) }, } }, _ => { Err(no_match(27, v_103)) }, } }, _ => { Err(no_match(27, v_100)) }, } }, _ => { Err(no_match(27, v_97)) }, } }, _ => { Err(no_match(27, v_94)) }, } }, _ => { Err(no_match(27, v_91)) }, } }, _ => { Err(no_match(27, v_88)) }, } }, _ => { Err(no_match(27, v_85)) }, } }, _ => { Err(no_match(27, v_82)) }, } }, _ => { Err(no_match(27, v_79)) }, } }, _ => { Err(no_match(27, v_76)) }, } }, _ => { Err(no_match(27, v_73)) }, } }, _ => { Err(no_match(27, v_70)) }, } }, _ => { Err(no_match(27, v_67)) }, } }, _ => { Err(no_match(27, v_64)) }, } }, _ => { Err(no_match(27, v_61)) }, } }, _ => { Err(no_match(27, v_58)) }, } }, _ => { Err(no_match(27, v_55)) }, } }, _ => { Err(no_match(27, v_52)) }, } }, _ => { Err(no_match(27, v_49)) }, } }, _ => { Err(no_match(27, v_46)) }, } }, _ => { Err(no_match(27, v_43)) }, } }, _ => { Err(no_match(27, v_40)) }, } }, _ => { Err(no_match(27, v_37)) }, } }, _ => { Err(no_match(27, v_34)) }, } }, _ => { Err(no_match(27, v_31)) }, } }, _ => { Err(no_match(27, v_28)) }, } }, _ => { Err(no_match(27, v_25)) }, } }, _ => { Err(no_match(27, v_22)) }, } }, _ => { Err(no_match(27, v_19)) }, } }, _ => { Err(no_match(27, v_16)) }, } }, _ => { Err(no_match(27, v_13)) }, } }, _ => { Err(no_match(27, v_10)) }, } }, _ => { Err(no_match(27, v_7)) }, } }, _ => { Err(no_match(27, v_4)) }, } }, _ => { Err(no_match(27, v_1)) }, } } + +fn pack_27_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(784, v_1); seed.full(8, v_2); seed.u32(532, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed.u8(785, v_4); seed.full(16, v_5); seed.u32(536, v_6); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed.u8(786, v_7); seed.full(24, v_8); seed.u32(540, v_9); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed.u8(787, v_10); seed.full(32, v_11); seed.u32(544, v_12); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed.u8(788, v_13); seed.full(40, v_14); seed.u32(548, v_15); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed.u8(789, v_16); seed.full(48, v_17); seed.u32(552, v_18); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed.u8(790, v_19); seed.full(56, v_20); seed.u32(556, v_21); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed.u8(791, v_22); seed.full(64, v_23); seed.u32(560, v_24); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed.u8(792, v_25); seed.full(72, v_26); seed.u32(564, v_27); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed.u8(793, v_28); seed.full(80, v_29); seed.u32(568, v_30); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed.u8(794, v_31); seed.full(88, v_32); seed.u32(572, v_33); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed.u8(795, v_34); seed.full(96, v_35); seed.u32(576, v_36); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed.u8(796, v_37); seed.full(104, v_38); seed.u32(580, v_39); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed.u8(797, v_40); seed.full(112, v_41); seed.u32(584, v_42); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed.u8(798, v_43); seed.full(120, v_44); seed.u32(588, v_45); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed.u8(799, v_46); seed.full(128, v_47); seed.u32(592, v_48); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed.u8(800, v_49); seed.full(136, v_50); seed.u32(596, v_51); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed.u8(801, v_52); seed.full(144, v_53); seed.u32(600, v_54); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed.u8(802, v_55); seed.full(152, v_56); seed.u32(604, v_57); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed.u8(803, v_58); seed.full(160, v_59); seed.u32(608, v_60); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed.u8(804, v_61); seed.full(168, v_62); seed.u32(612, v_63); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed.u8(805, v_64); seed.full(176, v_65); seed.u32(616, v_66); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed.u8(806, v_67); seed.full(184, v_68); seed.u32(620, v_69); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed.u8(807, v_70); seed.full(192, v_71); seed.u32(624, v_72); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed.u8(808, v_73); seed.full(200, v_74); seed.u32(628, v_75); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed.u8(809, v_76); seed.full(208, v_77); seed.u32(632, v_78); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed.u8(810, v_79); seed.full(216, v_80); seed.u32(636, v_81); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed.u8(811, v_82); seed.full(224, v_83); seed.u32(640, v_84); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed.u8(812, v_85); seed.full(232, v_86); seed.u32(644, v_87); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed.u8(813, v_88); seed.full(240, v_89); seed.u32(648, v_90); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed.u8(814, v_91); seed.full(248, v_92); seed.u32(652, v_93); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed.u8(815, v_94); seed.full(256, v_95); seed.u32(656, v_96); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed.u8(816, v_97); seed.full(264, v_98); seed.u32(660, v_99); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed.u8(817, v_100); seed.full(272, v_101); seed.u32(664, v_102); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed.u8(818, v_103); seed.full(280, v_104); seed.u32(668, v_105); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed.u8(819, v_106); seed.full(288, v_107); seed.u32(672, v_108); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed.u8(820, v_109); seed.full(296, v_110); seed.u32(676, v_111); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed.u8(821, v_112); seed.full(304, v_113); seed.u32(680, v_114); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed.u8(822, v_115); seed.full(312, v_116); seed.u32(684, v_117); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed.u8(823, v_118); seed.full(320, v_119); seed.u32(688, v_120); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed.u8(824, v_121); seed.full(328, v_122); seed.u32(692, v_123); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed.u8(825, v_124); seed.full(336, v_125); seed.u32(696, v_126); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed.u8(826, v_127); seed.full(344, v_128); seed.u32(700, v_129); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed.u8(827, v_130); seed.full(352, v_131); seed.u32(704, v_132); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed.u8(828, v_133); seed.full(360, v_134); seed.u32(708, v_135); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed.u8(829, v_136); seed.full(368, v_137); seed.u32(712, v_138); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed.u8(830, v_139); seed.full(376, v_140); seed.u32(716, v_141); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed.u8(831, v_142); seed.full(384, v_143); seed.u32(720, v_144); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed.u8(832, v_145); seed.full(392, v_146); seed.u32(724, v_147); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed.u8(833, v_148); seed.full(400, v_149); seed.u32(728, v_150); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed.u8(834, v_151); seed.full(408, v_152); seed.u32(732, v_153); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed.u8(835, v_154); seed.full(416, v_155); seed.u32(736, v_156); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed.u8(836, v_157); seed.full(424, v_158); seed.u32(740, v_159); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed.u8(837, v_160); seed.full(432, v_161); seed.u32(744, v_162); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed.u8(838, v_163); seed.full(440, v_164); seed.u32(748, v_165); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed.u8(839, v_166); seed.full(448, v_167); seed.u32(752, v_168); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed.u8(840, v_169); seed.full(456, v_170); seed.u32(756, v_171); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed.u8(841, v_172); seed.full(464, v_173); seed.u32(760, v_174); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed.u8(842, v_175); seed.full(472, v_176); seed.u32(764, v_177); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed.u8(843, v_178); seed.full(480, v_179); seed.u32(768, v_180); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed.u8(844, v_181); seed.full(488, v_182); seed.u32(772, v_183); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed.u8(845, v_184); seed.full(496, v_185); seed.u32(776, v_186); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed.u8(846, v_187); seed.full(504, v_188); seed.u32(780, v_189); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed.u8(847, v_190); seed.full(512, v_191); seed.full(520, v_192); Ok(()) }, _ => { Err(no_match(27, v_187)) }, } }, _ => { Err(no_match(27, v_184)) }, } }, _ => { Err(no_match(27, v_181)) }, } }, _ => { Err(no_match(27, v_178)) }, } }, _ => { Err(no_match(27, v_175)) }, } }, _ => { Err(no_match(27, v_172)) }, } }, _ => { Err(no_match(27, v_169)) }, } }, _ => { Err(no_match(27, v_166)) }, } }, _ => { Err(no_match(27, v_163)) }, } }, _ => { Err(no_match(27, v_160)) }, } }, _ => { Err(no_match(27, v_157)) }, } }, _ => { Err(no_match(27, v_154)) }, } }, _ => { Err(no_match(27, v_151)) }, } }, _ => { Err(no_match(27, v_148)) }, } }, _ => { Err(no_match(27, v_145)) }, } }, _ => { Err(no_match(27, v_142)) }, } }, _ => { Err(no_match(27, v_139)) }, } }, _ => { Err(no_match(27, v_136)) }, } }, _ => { Err(no_match(27, v_133)) }, } }, _ => { Err(no_match(27, v_130)) }, } }, _ => { Err(no_match(27, v_127)) }, } }, _ => { Err(no_match(27, v_124)) }, } }, _ => { Err(no_match(27, v_121)) }, } }, _ => { Err(no_match(27, v_118)) }, } }, _ => { Err(no_match(27, v_115)) }, } }, _ => { Err(no_match(27, v_112)) }, } }, _ => { Err(no_match(27, v_109)) }, } }, _ => { Err(no_match(27, v_106)) }, } }, _ => { Err(no_match(27, v_103)) }, } }, _ => { Err(no_match(27, v_100)) }, } }, _ => { Err(no_match(27, v_97)) }, } }, _ => { Err(no_match(27, v_94)) }, } }, _ => { Err(no_match(27, v_91)) }, } }, _ => { Err(no_match(27, v_88)) }, } }, _ => { Err(no_match(27, v_85)) }, } }, _ => { Err(no_match(27, v_82)) }, } }, _ => { Err(no_match(27, v_79)) }, } }, _ => { Err(no_match(27, v_76)) }, } }, _ => { Err(no_match(27, v_73)) }, } }, _ => { Err(no_match(27, v_70)) }, } }, _ => { Err(no_match(27, v_67)) }, } }, _ => { Err(no_match(27, v_64)) }, } }, _ => { Err(no_match(27, v_61)) }, } }, _ => { Err(no_match(27, v_58)) }, } }, _ => { Err(no_match(27, v_55)) }, } }, _ => { Err(no_match(27, v_52)) }, } }, _ => { Err(no_match(27, v_49)) }, } }, _ => { Err(no_match(27, v_46)) }, } }, _ => { Err(no_match(27, v_43)) }, } }, _ => { Err(no_match(27, v_40)) }, } }, _ => { Err(no_match(27, v_37)) }, } }, _ => { Err(no_match(27, v_34)) }, } }, _ => { Err(no_match(27, v_31)) }, } }, _ => { Err(no_match(27, v_28)) }, } }, _ => { Err(no_match(27, v_25)) }, } }, _ => { Err(no_match(27, v_22)) }, } }, _ => { Err(no_match(27, v_19)) }, } }, _ => { Err(no_match(27, v_16)) }, } }, _ => { Err(no_match(27, v_13)) }, } }, _ => { Err(no_match(27, v_10)) }, } }, _ => { Err(no_match(27, v_7)) }, } }, _ => { Err(no_match(27, v_4)) }, } }, _ => { Err(no_match(27, v_1)) }, } } + +fn write_27(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = [G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = [G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = [G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = [G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = [G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 52] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = [G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58])]; row[offsets.auxiliaries + 55] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = [G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 58] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 61] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67])]; row[offsets.auxiliaries + 64] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = [G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 67] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = [G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73])]; row[offsets.auxiliaries + 70] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = [G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76])]; row[offsets.auxiliaries + 73] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = [G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 76] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = [G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82])]; row[offsets.auxiliaries + 79] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = [G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85])]; row[offsets.auxiliaries + 82] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = [G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88])]; row[offsets.auxiliaries + 85] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = [G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91])]; row[offsets.auxiliaries + 88] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = [G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 91] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 94] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = [G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100])]; row[offsets.auxiliaries + 97] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = [G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103])]; row[offsets.auxiliaries + 100] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = [G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106])]; row[offsets.auxiliaries + 103] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = [G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109])]; row[offsets.auxiliaries + 106] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = [G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 109] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 112] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = [G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118])]; row[offsets.auxiliaries + 115] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = [G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121])]; row[offsets.auxiliaries + 118] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = [G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124])]; row[offsets.auxiliaries + 121] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = [G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127])]; row[offsets.auxiliaries + 124] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = [G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130])]; row[offsets.auxiliaries + 127] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = [G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133])]; row[offsets.auxiliaries + 130] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = [G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136])]; row[offsets.auxiliaries + 133] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = [G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139])]; row[offsets.auxiliaries + 136] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = [G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142])]; row[offsets.auxiliaries + 139] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = [G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 142] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = [G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 145] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151])]; row[offsets.auxiliaries + 148] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = [G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 151] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = [G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157])]; row[offsets.auxiliaries + 154] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = [G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160])]; row[offsets.auxiliaries + 157] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = [G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163])]; row[offsets.auxiliaries + 160] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = [G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166])]; row[offsets.auxiliaries + 163] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = [G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169])]; row[offsets.auxiliaries + 166] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = [G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172])]; row[offsets.auxiliaries + 169] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = [G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175])]; row[offsets.auxiliaries + 172] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = [G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178])]; row[offsets.auxiliaries + 175] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = [G::from_u64(seed[179]), G::from_u64(seed[180]), G::from_u64(seed[181])]; row[offsets.auxiliaries + 178] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = [G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184])]; row[offsets.auxiliaries + 181] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = [G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187])]; row[offsets.auxiliaries + 184] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = [G::from_u64(seed[188]), G::from_u64(seed[189]), G::from_u64(seed[190])]; row[offsets.auxiliaries + 187] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = [G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193])]; row[offsets.auxiliaries + 190] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_192.as_canonical_u64(); match v_190.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(27, v_190)) }, } }, _ => { Err(no_match(27, v_187)) }, } }, _ => { Err(no_match(27, v_184)) }, } }, _ => { Err(no_match(27, v_181)) }, } }, _ => { Err(no_match(27, v_178)) }, } }, _ => { Err(no_match(27, v_175)) }, } }, _ => { Err(no_match(27, v_172)) }, } }, _ => { Err(no_match(27, v_169)) }, } }, _ => { Err(no_match(27, v_166)) }, } }, _ => { Err(no_match(27, v_163)) }, } }, _ => { Err(no_match(27, v_160)) }, } }, _ => { Err(no_match(27, v_157)) }, } }, _ => { Err(no_match(27, v_154)) }, } }, _ => { Err(no_match(27, v_151)) }, } }, _ => { Err(no_match(27, v_148)) }, } }, _ => { Err(no_match(27, v_145)) }, } }, _ => { Err(no_match(27, v_142)) }, } }, _ => { Err(no_match(27, v_139)) }, } }, _ => { Err(no_match(27, v_136)) }, } }, _ => { Err(no_match(27, v_133)) }, } }, _ => { Err(no_match(27, v_130)) }, } }, _ => { Err(no_match(27, v_127)) }, } }, _ => { Err(no_match(27, v_124)) }, } }, _ => { Err(no_match(27, v_121)) }, } }, _ => { Err(no_match(27, v_118)) }, } }, _ => { Err(no_match(27, v_115)) }, } }, _ => { Err(no_match(27, v_112)) }, } }, _ => { Err(no_match(27, v_109)) }, } }, _ => { Err(no_match(27, v_106)) }, } }, _ => { Err(no_match(27, v_103)) }, } }, _ => { Err(no_match(27, v_100)) }, } }, _ => { Err(no_match(27, v_97)) }, } }, _ => { Err(no_match(27, v_94)) }, } }, _ => { Err(no_match(27, v_91)) }, } }, _ => { Err(no_match(27, v_88)) }, } }, _ => { Err(no_match(27, v_85)) }, } }, _ => { Err(no_match(27, v_82)) }, } }, _ => { Err(no_match(27, v_79)) }, } }, _ => { Err(no_match(27, v_76)) }, } }, _ => { Err(no_match(27, v_73)) }, } }, _ => { Err(no_match(27, v_70)) }, } }, _ => { Err(no_match(27, v_67)) }, } }, _ => { Err(no_match(27, v_64)) }, } }, _ => { Err(no_match(27, v_61)) }, } }, _ => { Err(no_match(27, v_58)) }, } }, _ => { Err(no_match(27, v_55)) }, } }, _ => { Err(no_match(27, v_52)) }, } }, _ => { Err(no_match(27, v_49)) }, } }, _ => { Err(no_match(27, v_46)) }, } }, _ => { Err(no_match(27, v_43)) }, } }, _ => { Err(no_match(27, v_40)) }, } }, _ => { Err(no_match(27, v_37)) }, } }, _ => { Err(no_match(27, v_34)) }, } }, _ => { Err(no_match(27, v_31)) }, } }, _ => { Err(no_match(27, v_28)) }, } }, _ => { Err(no_match(27, v_25)) }, } }, _ => { Err(no_match(27, v_22)) }, } }, _ => { Err(no_match(27, v_19)) }, } }, _ => { Err(no_match(27, v_16)) }, } }, _ => { Err(no_match(27, v_13)) }, } }, _ => { Err(no_match(27, v_10)) }, } }, _ => { Err(no_match(27, v_7)) }, } }, _ => { Err(no_match(27, v_4)) }, } }, _ => { Err(no_match(27, v_1)) }, } } + +static SCHEMA_27: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 528, 784, 8, 532, 785, 16, 536, 786, 24, 540, 787, 32, 544, 788, 40, 548, 789, 48, 552, 790, 56, 556, 791, 64, 560, 792, 72, 564, 793, 80, 568, 794, 88, 572, 795, 96, 576, 796, 104, 580, 797, 112, 584, 798, 120, 588, 799, 128, 592, 800, 136, 596, 801, 144, 600, 802, 152, 604, 803, 160, 608, 804, 168, 612, 805, 176, 616, 806, 184, 620, 807, 192, 624, 808, 200, 628, 809, 208, 632, 810, 216, 636, 811, 224, 640, 812, 232, 644, 813, 240, 648, 814, 248, 652, 815, 256, 656, 816, 264, 660, 817, 272, 664, 818, 280, 668, 819, 288, 672, 820, 296, 676, 821, 304, 680, 822, 312, 684, 823, 320, 688, 824, 328, 692, 825, 336, 696, 826, 344, 700, 827, 352, 704, 828, 360, 708, 829, 368, 712, 830, 376, 716, 831, 384, 720, 832, 392, 724, 833, 400, 728, 834, 408, 732, 835, 416, 736, 836, 424, 740, 837, 432, 744, 838, 440, 748, 839, 448, 752, 840, 456, 756, 841, 464, 760, 842, 472, 764, 843, 480, 768, 844, 488, 772, 845, 496, 776, 846, 504, 780, 847, 512, 520], bytes: 848 }; + +fn pack_30(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 64] = context.call::<64>(3, 27, &[v_1])?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); seed[47] = v_49.as_canonical_u64(); seed[48] = v_50.as_canonical_u64(); seed[49] = v_51.as_canonical_u64(); seed[50] = v_52.as_canonical_u64(); seed[51] = v_53.as_canonical_u64(); seed[52] = v_54.as_canonical_u64(); seed[53] = v_55.as_canonical_u64(); seed[54] = v_56.as_canonical_u64(); seed[55] = v_57.as_canonical_u64(); seed[56] = v_58.as_canonical_u64(); seed[57] = v_59.as_canonical_u64(); seed[58] = v_60.as_canonical_u64(); seed[59] = v_61.as_canonical_u64(); seed[60] = v_62.as_canonical_u64(); seed[61] = v_63.as_canonical_u64(); seed[62] = v_64.as_canonical_u64(); seed[63] = v_65.as_canonical_u64(); seed[64] = v_66.as_canonical_u64(); seed[65] = v_67.as_canonical_u64(); seed[66] = v_68.as_canonical_u64(); seed[67] = v_69.as_canonical_u64(); seed[68] = v_70.as_canonical_u64(); seed[69] = v_71.as_canonical_u64(); seed[70] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 798, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed[72] = v_74.as_canonical_u64(); seed[73] = v_75.as_canonical_u64(); seed[74] = v_76.as_canonical_u64(); seed[75] = v_77.as_canonical_u64(); seed[76] = v_78.as_canonical_u64(); seed[77] = v_79.as_canonical_u64(); seed[78] = v_80.as_canonical_u64(); seed[79] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(6, 6, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[80] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_117.as_canonical_u64(); seed[82] = v_118.as_canonical_u64(); seed[83] = v_119.as_canonical_u64(); seed[84] = v_120.as_canonical_u64(); seed[85] = v_121.as_canonical_u64(); seed[86] = v_122.as_canonical_u64(); seed[87] = v_123.as_canonical_u64(); seed[88] = v_124.as_canonical_u64(); seed[89] = v_125.as_canonical_u64(); seed[90] = v_126.as_canonical_u64(); seed[91] = v_127.as_canonical_u64(); seed[92] = v_128.as_canonical_u64(); seed[93] = v_129.as_canonical_u64(); seed[94] = v_130.as_canonical_u64(); seed[95] = v_131.as_canonical_u64(); seed[96] = v_132.as_canonical_u64(); seed[97] = v_133.as_canonical_u64(); seed[98] = v_134.as_canonical_u64(); seed[99] = v_135.as_canonical_u64(); seed[100] = v_136.as_canonical_u64(); seed[101] = v_137.as_canonical_u64(); seed[102] = v_138.as_canonical_u64(); seed[103] = v_139.as_canonical_u64(); seed[104] = v_140.as_canonical_u64(); seed[105] = v_141.as_canonical_u64(); seed[106] = v_142.as_canonical_u64(); seed[107] = v_143.as_canonical_u64(); seed[108] = v_144.as_canonical_u64(); seed[109] = v_145.as_canonical_u64(); seed[110] = v_146.as_canonical_u64(); seed[111] = v_147.as_canonical_u64(); seed[112] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 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])?; seed[113] = v_151.as_canonical_u64(); seed[114] = v_152.as_canonical_u64(); seed[115] = v_153.as_canonical_u64(); seed[116] = v_154.as_canonical_u64(); seed[117] = v_155.as_canonical_u64(); seed[118] = v_156.as_canonical_u64(); seed[119] = v_157.as_canonical_u64(); seed[120] = v_158.as_canonical_u64(); seed[121] = v_159.as_canonical_u64(); seed[122] = v_160.as_canonical_u64(); seed[123] = v_161.as_canonical_u64(); seed[124] = v_162.as_canonical_u64(); seed[125] = v_163.as_canonical_u64(); seed[126] = v_164.as_canonical_u64(); seed[127] = v_165.as_canonical_u64(); seed[128] = v_166.as_canonical_u64(); seed[129] = v_167.as_canonical_u64(); seed[130] = v_168.as_canonical_u64(); seed[131] = v_169.as_canonical_u64(); seed[132] = v_170.as_canonical_u64(); seed[133] = v_171.as_canonical_u64(); seed[134] = v_172.as_canonical_u64(); seed[135] = v_173.as_canonical_u64(); seed[136] = v_174.as_canonical_u64(); seed[137] = v_175.as_canonical_u64(); seed[138] = v_176.as_canonical_u64(); seed[139] = v_177.as_canonical_u64(); seed[140] = v_178.as_canonical_u64(); seed[141] = v_179.as_canonical_u64(); seed[142] = v_180.as_canonical_u64(); seed[143] = v_181.as_canonical_u64(); seed[144] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed[145] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed[146] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 16, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[147] = v_186.as_canonical_u64(); seed[148] = v_187.as_canonical_u64(); seed[149] = v_188.as_canonical_u64(); seed[150] = v_189.as_canonical_u64(); seed[151] = v_190.as_canonical_u64(); seed[152] = v_191.as_canonical_u64(); seed[153] = v_192.as_canonical_u64(); seed[154] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed[155] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116])?; seed[156] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed[157] = v_196.as_canonical_u64(); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 798, &[v_0])?; seed[71] = v_197.as_canonical_u64(); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 798, &[v_0])?; seed[72] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed[73] = v_200.as_canonical_u64(); seed[74] = v_201.as_canonical_u64(); seed[75] = v_202.as_canonical_u64(); seed[76] = v_203.as_canonical_u64(); seed[77] = v_204.as_canonical_u64(); seed[78] = v_205.as_canonical_u64(); seed[79] = v_206.as_canonical_u64(); seed[80] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = context.call::<1>(56, 6, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed[81] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed[82] = v_217.as_canonical_u64(); seed[83] = v_218.as_canonical_u64(); seed[84] = v_219.as_canonical_u64(); seed[85] = v_220.as_canonical_u64(); seed[86] = v_221.as_canonical_u64(); seed[87] = v_222.as_canonical_u64(); seed[88] = v_223.as_canonical_u64(); seed[89] = v_224.as_canonical_u64(); seed[90] = v_225.as_canonical_u64(); seed[91] = v_226.as_canonical_u64(); seed[92] = v_227.as_canonical_u64(); seed[93] = v_228.as_canonical_u64(); seed[94] = v_229.as_canonical_u64(); seed[95] = v_230.as_canonical_u64(); seed[96] = v_231.as_canonical_u64(); seed[97] = v_232.as_canonical_u64(); seed[98] = v_233.as_canonical_u64(); seed[99] = v_234.as_canonical_u64(); seed[100] = v_235.as_canonical_u64(); seed[101] = v_236.as_canonical_u64(); seed[102] = v_237.as_canonical_u64(); seed[103] = v_238.as_canonical_u64(); seed[104] = v_239.as_canonical_u64(); seed[105] = v_240.as_canonical_u64(); seed[106] = v_241.as_canonical_u64(); seed[107] = v_242.as_canonical_u64(); seed[108] = v_243.as_canonical_u64(); seed[109] = v_244.as_canonical_u64(); seed[110] = v_245.as_canonical_u64(); seed[111] = v_246.as_canonical_u64(); seed[112] = v_247.as_canonical_u64(); seed[113] = v_248.as_canonical_u64(); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 34, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[114] = v_266.as_canonical_u64(); seed[115] = v_267.as_canonical_u64(); seed[116] = v_268.as_canonical_u64(); seed[117] = v_269.as_canonical_u64(); seed[118] = v_270.as_canonical_u64(); seed[119] = v_271.as_canonical_u64(); seed[120] = v_272.as_canonical_u64(); seed[121] = v_273.as_canonical_u64(); seed[122] = v_274.as_canonical_u64(); seed[123] = v_275.as_canonical_u64(); seed[124] = v_276.as_canonical_u64(); seed[125] = v_277.as_canonical_u64(); seed[126] = v_278.as_canonical_u64(); seed[127] = v_279.as_canonical_u64(); seed[128] = v_280.as_canonical_u64(); seed[129] = v_281.as_canonical_u64(); seed[130] = v_282.as_canonical_u64(); seed[131] = v_283.as_canonical_u64(); seed[132] = v_284.as_canonical_u64(); seed[133] = v_285.as_canonical_u64(); seed[134] = v_286.as_canonical_u64(); seed[135] = v_287.as_canonical_u64(); seed[136] = v_288.as_canonical_u64(); seed[137] = v_289.as_canonical_u64(); seed[138] = v_290.as_canonical_u64(); seed[139] = v_291.as_canonical_u64(); seed[140] = v_292.as_canonical_u64(); seed[141] = v_293.as_canonical_u64(); seed[142] = v_294.as_canonical_u64(); seed[143] = v_295.as_canonical_u64(); seed[144] = v_296.as_canonical_u64(); seed[145] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed[146] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed[147] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed[148] = v_302.as_canonical_u64(); Ok(()) }, } } + +fn pack_30_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 64] = context.call::<64>(3, 27, &[v_1])?; seed.u8(128, v_9); seed.u8(129, v_10); seed.u8(130, v_11); seed.u8(131, v_12); seed.u8(132, v_13); seed.u8(133, v_14); seed.u8(134, v_15); seed.u8(135, v_16); seed.u8(136, v_17); seed.u8(137, v_18); seed.u8(138, v_19); seed.u8(139, v_20); seed.u8(140, v_21); seed.u8(141, v_22); seed.u8(142, v_23); seed.u8(143, v_24); seed.u8(144, v_25); seed.u8(145, v_26); seed.u8(146, v_27); seed.u8(147, v_28); seed.u8(148, v_29); seed.u8(149, v_30); seed.u8(150, v_31); seed.u8(151, v_32); seed.u8(152, v_33); seed.u8(153, v_34); seed.u8(154, v_35); seed.u8(155, v_36); seed.u8(156, v_37); seed.u8(157, v_38); seed.u8(158, v_39); seed.u8(159, v_40); seed.u8(160, v_41); seed.u8(161, v_42); seed.u8(162, v_43); seed.u8(163, v_44); seed.u8(164, v_45); seed.u8(165, v_46); seed.u8(166, v_47); seed.u8(167, v_48); seed.u8(168, v_49); seed.u8(169, v_50); seed.u8(170, v_51); seed.u8(171, v_52); seed.u8(172, v_53); seed.u8(173, v_54); seed.u8(174, v_55); seed.u8(175, v_56); seed.u8(176, v_57); seed.u8(177, v_58); seed.u8(178, v_59); seed.u8(179, v_60); seed.u8(180, v_61); seed.u8(181, v_62); seed.u8(182, v_63); seed.u8(183, v_64); seed.u8(184, v_65); seed.u8(185, v_66); seed.u8(186, v_67); seed.u8(187, v_68); seed.u8(188, v_69); seed.u8(189, v_70); seed.u8(190, v_71); seed.u8(191, v_72); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 798, &[v_0])?; seed.u8(192, v_73); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed.u8(193, v_74); seed.u8(194, v_75); seed.u8(195, v_76); seed.u8(196, v_77); seed.u8(197, v_78); seed.u8(198, v_79); seed.u8(199, v_80); seed.u8(200, v_81); let [v_82]: [G; 1] = context.call::<1>(6, 6, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.u8(201, v_82); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed.u8(202, v_117); seed.u8(203, v_118); seed.u8(204, v_119); seed.u8(205, v_120); seed.u8(206, v_121); seed.u8(207, v_122); seed.u8(208, v_123); seed.u8(209, v_124); seed.u8(210, v_125); seed.u8(211, v_126); seed.u8(212, v_127); seed.u8(213, v_128); seed.u8(214, v_129); seed.u8(215, v_130); seed.u8(216, v_131); seed.u8(217, v_132); seed.u8(218, v_133); seed.u8(219, v_134); seed.u8(220, v_135); seed.u8(221, v_136); seed.u8(222, v_137); seed.u8(223, v_138); seed.u8(224, v_139); seed.u8(225, v_140); seed.u8(226, v_141); seed.u8(227, v_142); seed.u8(228, v_143); seed.u8(229, v_144); seed.u8(230, v_145); seed.u8(231, v_146); seed.u8(232, v_147); seed.u8(233, v_148); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 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])?; seed.u8(234, v_151); seed.u8(235, v_152); seed.u8(236, v_153); seed.u8(237, v_154); seed.u8(238, v_155); seed.u8(239, v_156); seed.u8(240, v_157); seed.u8(241, v_158); seed.u8(242, v_159); seed.u8(243, v_160); seed.u8(244, v_161); seed.u8(245, v_162); seed.u8(246, v_163); seed.u8(247, v_164); seed.u8(248, v_165); seed.u8(249, v_166); seed.u8(250, v_167); seed.u8(251, v_168); seed.u8(252, v_169); seed.u8(253, v_170); seed.u8(254, v_171); seed.u8(255, v_172); seed.u8(256, v_173); seed.u8(257, v_174); seed.u8(258, v_175); seed.u8(259, v_176); seed.u8(260, v_177); seed.u8(261, v_178); seed.u8(262, v_179); seed.u8(263, v_180); seed.u8(264, v_181); seed.u8(265, v_182); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed.u32(112, v_183); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed.u32(116, v_185); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 16, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.full(24, v_186); seed.full(32, v_187); seed.full(40, v_188); seed.full(48, v_189); seed.full(56, v_190); seed.full(64, v_191); seed.full(72, v_192); seed.full(80, v_193); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed.u32(120, v_194); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116])?; seed.u32(124, v_195); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed.full(88, v_196); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 798, &[v_0])?; seed.u8(192, v_197); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 798, &[v_0])?; seed.u8(193, v_199); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed.u8(194, v_200); seed.u8(195, v_201); seed.u8(196, v_202); seed.u8(197, v_203); seed.u8(198, v_204); seed.u8(199, v_205); seed.u8(200, v_206); seed.u8(201, v_207); let [v_208]: [G; 1] = context.call::<1>(56, 6, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed.u8(202, v_208); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed.u8(203, v_217); seed.u8(204, v_218); seed.u8(205, v_219); seed.u8(206, v_220); seed.u8(207, v_221); seed.u8(208, v_222); seed.u8(209, v_223); seed.u8(210, v_224); seed.u8(211, v_225); seed.u8(212, v_226); seed.u8(213, v_227); seed.u8(214, v_228); seed.u8(215, v_229); seed.u8(216, v_230); seed.u8(217, v_231); seed.u8(218, v_232); seed.u8(219, v_233); seed.u8(220, v_234); seed.u8(221, v_235); seed.u8(222, v_236); seed.u8(223, v_237); seed.u8(224, v_238); seed.u8(225, v_239); seed.u8(226, v_240); seed.u8(227, v_241); seed.u8(228, v_242); seed.u8(229, v_243); seed.u8(230, v_244); seed.u8(231, v_245); seed.u8(232, v_246); seed.u8(233, v_247); seed.u8(234, v_248); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 34, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed.u8(235, v_266); seed.u8(236, v_267); seed.u8(237, v_268); seed.u8(238, v_269); seed.u8(239, v_270); seed.u8(240, v_271); seed.u8(241, v_272); seed.u8(242, v_273); seed.u8(243, v_274); seed.u8(244, v_275); seed.u8(245, v_276); seed.u8(246, v_277); seed.u8(247, v_278); seed.u8(248, v_279); seed.u8(249, v_280); seed.u8(250, v_281); seed.u8(251, v_282); seed.u8(252, v_283); seed.u8(253, v_284); seed.u8(254, v_285); seed.u8(255, v_286); seed.u8(256, v_287); seed.u8(257, v_288); seed.u8(258, v_289); seed.u8(259, v_290); seed.u8(260, v_291); seed.u8(261, v_292); seed.u8(262, v_293); seed.u8(263, v_294); seed.u8(264, v_295); seed.u8(265, v_296); seed.u32(112, v_297); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed.u32(116, v_299); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed.full(24, v_301); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed.full(32, v_302); Ok(()) }, } } + +fn write_30(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 64] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 65] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = [G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 66] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = [G::from_u64(seed[80])]; row[offsets.auxiliaries + 74] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; row[offsets.auxiliaries + 75] = v_83.as_canonical_u64(); let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = [G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 76] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_148.as_canonical_u64(); let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144])]; row[offsets.auxiliaries + 108] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = [G::from_u64(seed[145])]; row[offsets.auxiliaries + 140] = v_183.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 141] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = [G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 142] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = [G::from_u64(seed[155])]; row[offsets.auxiliaries + 150] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = [G::from_u64(seed[156])]; row[offsets.auxiliaries + 151] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [G::from_u64(seed[157])]; row[offsets.auxiliaries + 152] = v_196.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 65] = (v_2 - G::from_u64(1023)).inverse().as_canonical_u64(); let [v_197]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 66] = v_197.as_canonical_u64(); let [v_199]: [G; 1] = [G::from_u64(seed[72])]; row[offsets.auxiliaries + 67] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 68] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = [G::from_u64(seed[81])]; row[offsets.auxiliaries + 76] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; row[offsets.auxiliaries + 77] = v_210.as_canonical_u64(); let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; row[offsets.auxiliaries + 78] = g_inverse_value(v_212).as_canonical_u64(); row[offsets.auxiliaries + 79] = v_213.as_canonical_u64(); let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = [G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113])]; row[offsets.auxiliaries + 80] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_223.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_248.as_canonical_u64(); let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = [G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 112] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_273.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_277.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_279.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_281.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_283.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_284.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_285.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_286.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_287.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_297.as_canonical_u64(); let [v_299]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 144] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = [G::from_u64(seed[147])]; row[offsets.auxiliaries + 145] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = [G::from_u64(seed[148])]; row[offsets.auxiliaries + 146] = v_302.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_30: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 96, 100, 8, 104, 108, 16, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 112, 116, 24, 32, 40, 48, 56, 64, 72, 80, 120, 124, 88], bytes: 272 }; + +fn pack_34(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_34_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn write_34(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_34: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_38(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = [v_7 + v_8]; let [v_11]: [G; 1] = [v_6 + v_10]; let [v_12]: [G; 1] = [v_5 + v_11]; let [v_13]: [G; 1] = [v_4 + v_12]; let [v_14]: [G; 1] = [v_3 + v_13]; let [v_15]: [G; 1] = [v_2 + v_14]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(32)]; let [v_17]: [G; 1] = [Bytes2::less_than(&v_1, &v_16)]; match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = [G::from_u64(64)]; let [v_20]: [G; 1] = [v_19 * v_0]; let [v_21]: [G; 1] = [v_20 + v_1]; let [v_22]: [G; 1] = context.store(12, &[v_18, v_21, v_9])?; seed[11] = v_22.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_26]: [G; 1] = context.returned::<1>(16)?; seed[11] = v_26.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(38, v_17)) }, } }, _ => { let [v_30]: [G; 1] = context.returned::<1>(20)?; seed[11] = v_30.as_canonical_u64(); Ok(()) }, } } + +fn pack_38_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = [v_7 + v_8]; let [v_11]: [G; 1] = [v_6 + v_10]; let [v_12]: [G; 1] = [v_5 + v_11]; let [v_13]: [G; 1] = [v_4 + v_12]; let [v_14]: [G; 1] = [v_3 + v_13]; let [v_15]: [G; 1] = [v_2 + v_14]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(32)]; let [v_17]: [G; 1] = [Bytes2::less_than(&v_1, &v_16)]; match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = [G::from_u64(64)]; let [v_20]: [G; 1] = [v_19 * v_0]; let [v_21]: [G; 1] = [v_20 + v_1]; let [v_22]: [G; 1] = context.store(12, &[v_18, v_21, v_9])?; seed.u32(24, v_22); Ok(()) }, 0u64 => { let [v_26]: [G; 1] = context.returned::<1>(16)?; seed.u32(24, v_26); Ok(()) }, _ => { Err(no_match(38, v_17)) }, } }, _ => { let [v_30]: [G; 1] = context.returned::<1>(20)?; seed.u32(24, v_30); Ok(()) }, } } + +fn write_38(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let [v_10]: [G; 1] = [v_7 + v_8]; let [v_11]: [G; 1] = [v_6 + v_10]; let [v_12]: [G; 1] = [v_5 + v_11]; let [v_13]: [G; 1] = [v_4 + v_12]; let [v_14]: [G; 1] = [v_3 + v_13]; let [v_15]: [G; 1] = [v_2 + v_14]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(32)]; let [v_17]: [G; 1] = [Bytes2::less_than(&v_1, &v_16)]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_22.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_26]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_26.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(38, v_17)) }, } }, _ => { row[offsets.auxiliaries + 1] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_30.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } } + +static SCHEMA_38: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 8, 28, 29, 30, 31, 32, 33, 34, 35, 16, 24], bytes: 40 }; + +fn pack_40(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let [v_11]: [G; 1] = [G::from_u64(256)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_13]: [G; 1] = [v_12 * v_1]; let [v_14]: [G; 1] = [v_11 - v_13]; let [v_15]: [G; 1] = [G::from_u64(255)]; let [v_16]: [G; 1] = [v_15 - v_1]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 9] = context.call::<9>(6, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_16, v_15, v_15, v_15, v_15, v_15, v_15])?; seed[12] = v_17.as_canonical_u64(); seed[13] = v_18.as_canonical_u64(); seed[14] = v_19.as_canonical_u64(); seed[15] = v_20.as_canonical_u64(); seed[16] = v_21.as_canonical_u64(); seed[17] = v_22.as_canonical_u64(); seed[18] = v_23.as_canonical_u64(); seed[19] = v_24.as_canonical_u64(); seed[20] = v_25.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_26]: [G; 1] = [G::from_u64(256)]; let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [v_27 * v_1]; let [v_29]: [G; 1] = [v_26 - v_28]; let op_11 = Bytes2::add(&v_2, &v_29); let [v_30, v_31]: [G; 2] = [op_11.0, op_11.1]; let [v_32]: [G; 1] = [G::from_u64(1)]; let [v_33]: [G; 1] = [v_31 - v_32]; let [v_34]: [G; 1] = [v_3 + v_33]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = [v_28 + v_34]; let [v_37]: [G; 1] = [v_0 + v_36]; let [v_38]: [G; 1] = context.store(18, &[v_35, v_30, v_10])?; seed[21] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(19, &[v_35, v_37, v_38])?; seed[22] = v_39.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_44]: [G; 1] = context.returned::<1>(24)?; seed[21] = v_44.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(40, v_25)) }, } } + +fn pack_40_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let [v_11]: [G; 1] = [G::from_u64(256)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_13]: [G; 1] = [v_12 * v_1]; let [v_14]: [G; 1] = [v_11 - v_13]; let [v_15]: [G; 1] = [G::from_u64(255)]; let [v_16]: [G; 1] = [v_15 - v_1]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 9] = context.call::<9>(6, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_16, v_15, v_15, v_15, v_15, v_15, v_15])?; seed.u8(48, v_17); seed.u8(49, v_18); seed.u8(50, v_19); seed.u8(51, v_20); seed.u8(52, v_21); seed.u8(53, v_22); seed.u8(54, v_23); seed.u8(55, v_24); seed.u8(56, v_25); match v_25.as_canonical_u64() { 0u64 => { let [v_26]: [G; 1] = [G::from_u64(256)]; let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [v_27 * v_1]; let [v_29]: [G; 1] = [v_26 - v_28]; let op_11 = Bytes2::add(&v_2, &v_29); let [v_30, v_31]: [G; 2] = [op_11.0, op_11.1]; let [v_32]: [G; 1] = [G::from_u64(1)]; let [v_33]: [G; 1] = [v_31 - v_32]; let [v_34]: [G; 1] = [v_3 + v_33]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = [v_28 + v_34]; let [v_37]: [G; 1] = [v_0 + v_36]; let [v_38]: [G; 1] = context.store(18, &[v_35, v_30, v_10])?; seed.u32(32, v_38); let [v_39]: [G; 1] = context.store(19, &[v_35, v_37, v_38])?; seed.u32(36, v_39); Ok(()) }, 1u64 => { let [v_44]: [G; 1] = context.returned::<1>(24)?; seed.u32(32, v_44); Ok(()) }, _ => { Err(no_match(40, v_25)) }, } } + +fn write_40(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_25.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_26]: [G; 1] = [G::from_u64(256)]; let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [v_27 * v_1]; let [v_29]: [G; 1] = [v_26 - v_28]; let op_11 = Bytes2::add(&v_2, &v_29); let [v_30, v_31]: [G; 2] = [op_11.0, op_11.1]; row[offsets.auxiliaries + 10] = v_30.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 12] = v_39.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_44]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 10] = v_44.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(40, v_25)) }, } } + +static SCHEMA_40: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 16, 40, 41, 42, 43, 44, 45, 46, 47, 24, 48, 49, 50, 51, 52, 53, 54, 55, 56, 32, 36], bytes: 64 }; + +fn pack_41(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [v_8 + v_9]; let [v_12]: [G; 1] = [v_7 + v_11]; let [v_13]: [G; 1] = [v_6 + v_12]; let [v_14]: [G; 1] = [v_5 + v_13]; let [v_15]: [G; 1] = [v_4 + v_14]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(0)]; let [v_17]: [G; 1] = [G::from_u64(2)]; let [v_18]: [G; 1] = context.call::<1>(7, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_17, v_10])?; seed[12] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.store(8, &[v_16, v_0, v_18])?; seed[13] = v_19.as_canonical_u64(); Ok(()) }, _ => { let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = [G::from_u64(255)]; let [v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 9] = context.call::<9>(11, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_20, v_20, v_21, v_21, v_21, v_21, v_21, v_21])?; seed[12] = v_22.as_canonical_u64(); seed[13] = v_23.as_canonical_u64(); seed[14] = v_24.as_canonical_u64(); seed[15] = v_25.as_canonical_u64(); seed[16] = v_26.as_canonical_u64(); seed[17] = v_27.as_canonical_u64(); seed[18] = v_28.as_canonical_u64(); seed[19] = v_29.as_canonical_u64(); seed[20] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = context.returned::<1>(13)?; seed[21] = v_32.as_canonical_u64(); Ok(()) }, } }, 1u64 => { let [v_33]: [G; 1] = [v_8 + v_9]; let [v_34]: [G; 1] = [v_7 + v_33]; let [v_35]: [G; 1] = [v_6 + v_34]; let [v_36]: [G; 1] = [v_5 + v_35]; match v_36.as_canonical_u64() { 0u64 => { let [v_37]: [G; 1] = [G::from_u64(0)]; let [v_38]: [G; 1] = [G::from_u64(1)]; let [v_39]: [G; 1] = [v_0 + v_38]; let [v_40]: [G; 1] = [G::from_u64(3)]; let [v_41]: [G; 1] = context.call::<1>(22, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_40, v_10])?; seed[12] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.store(23, &[v_37, v_39, v_41])?; seed[13] = v_42.as_canonical_u64(); Ok(()) }, _ => { let [v_43]: [G; 1] = [G::from_u64(0)]; let [v_44]: [G; 1] = [G::from_u64(255)]; let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 9] = context.call::<9>(26, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_43, v_43, v_43, v_44, v_44, v_44, v_44, v_44])?; seed[12] = v_45.as_canonical_u64(); seed[13] = v_46.as_canonical_u64(); seed[14] = v_47.as_canonical_u64(); seed[15] = v_48.as_canonical_u64(); seed[16] = v_49.as_canonical_u64(); seed[17] = v_50.as_canonical_u64(); seed[18] = v_51.as_canonical_u64(); seed[19] = v_52.as_canonical_u64(); seed[20] = v_53.as_canonical_u64(); let [v_55]: [G; 1] = context.returned::<1>(28)?; seed[21] = v_55.as_canonical_u64(); Ok(()) }, } }, 2u64 => { let [v_56]: [G; 1] = [v_8 + v_9]; let [v_57]: [G; 1] = [v_7 + v_56]; let [v_58]: [G; 1] = [v_6 + v_57]; match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = [G::from_u64(2)]; let [v_61]: [G; 1] = [v_0 + v_60]; let [v_62]: [G; 1] = [G::from_u64(4)]; let [v_63]: [G; 1] = context.call::<1>(36, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_62, v_10])?; seed[12] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = context.store(37, &[v_59, v_61, v_63])?; seed[13] = v_64.as_canonical_u64(); Ok(()) }, _ => { let [v_65]: [G; 1] = [G::from_u64(0)]; let [v_66]: [G; 1] = [G::from_u64(255)]; let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75]: [G; 9] = context.call::<9>(40, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_65, v_65, v_65, v_65, v_66, v_66, v_66, v_66])?; seed[12] = v_67.as_canonical_u64(); seed[13] = v_68.as_canonical_u64(); seed[14] = v_69.as_canonical_u64(); seed[15] = v_70.as_canonical_u64(); seed[16] = v_71.as_canonical_u64(); seed[17] = v_72.as_canonical_u64(); seed[18] = v_73.as_canonical_u64(); seed[19] = v_74.as_canonical_u64(); seed[20] = v_75.as_canonical_u64(); let [v_77]: [G; 1] = context.returned::<1>(42)?; seed[21] = v_77.as_canonical_u64(); Ok(()) }, } }, 3u64 => { let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79]: [G; 1] = [G::from_u64(3)]; let [v_80]: [G; 1] = [v_0 + v_79]; let [v_81]: [G; 1] = [G::from_u64(8)]; let [v_82]: [G; 1] = context.call::<1>(47, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_81, v_10])?; seed[12] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.store(48, &[v_78, v_80, v_82])?; seed[13] = v_83.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(41, v_1)) }, } } + +fn pack_41_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [v_8 + v_9]; let [v_12]: [G; 1] = [v_7 + v_11]; let [v_13]: [G; 1] = [v_6 + v_12]; let [v_14]: [G; 1] = [v_5 + v_13]; let [v_15]: [G; 1] = [v_4 + v_14]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(0)]; let [v_17]: [G; 1] = [G::from_u64(2)]; let [v_18]: [G; 1] = context.call::<1>(7, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_17, v_10])?; seed.full(24, v_18); let [v_19]: [G; 1] = context.store(8, &[v_16, v_0, v_18])?; seed.u32(32, v_19); Ok(()) }, _ => { let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = [G::from_u64(255)]; let [v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 9] = context.call::<9>(11, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_20, v_20, v_21, v_21, v_21, v_21, v_21, v_21])?; seed.full(24, v_22); seed.u32(32, v_23); seed.u8(49, v_24); seed.u8(50, v_25); seed.u8(51, v_26); seed.u8(52, v_27); seed.u8(53, v_28); seed.u8(54, v_29); seed.u8(55, v_30); let [v_32]: [G; 1] = context.returned::<1>(13)?; seed.u32(36, v_32); Ok(()) }, } }, 1u64 => { let [v_33]: [G; 1] = [v_8 + v_9]; let [v_34]: [G; 1] = [v_7 + v_33]; let [v_35]: [G; 1] = [v_6 + v_34]; let [v_36]: [G; 1] = [v_5 + v_35]; match v_36.as_canonical_u64() { 0u64 => { let [v_37]: [G; 1] = [G::from_u64(0)]; let [v_38]: [G; 1] = [G::from_u64(1)]; let [v_39]: [G; 1] = [v_0 + v_38]; let [v_40]: [G; 1] = [G::from_u64(3)]; let [v_41]: [G; 1] = context.call::<1>(22, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_40, v_10])?; seed.full(24, v_41); let [v_42]: [G; 1] = context.store(23, &[v_37, v_39, v_41])?; seed.u32(32, v_42); Ok(()) }, _ => { let [v_43]: [G; 1] = [G::from_u64(0)]; let [v_44]: [G; 1] = [G::from_u64(255)]; let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 9] = context.call::<9>(26, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_43, v_43, v_43, v_44, v_44, v_44, v_44, v_44])?; seed.full(24, v_45); seed.u32(32, v_46); seed.u8(49, v_47); seed.u8(50, v_48); seed.u8(51, v_49); seed.u8(52, v_50); seed.u8(53, v_51); seed.u8(54, v_52); seed.u8(55, v_53); let [v_55]: [G; 1] = context.returned::<1>(28)?; seed.u32(36, v_55); Ok(()) }, } }, 2u64 => { let [v_56]: [G; 1] = [v_8 + v_9]; let [v_57]: [G; 1] = [v_7 + v_56]; let [v_58]: [G; 1] = [v_6 + v_57]; match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = [G::from_u64(2)]; let [v_61]: [G; 1] = [v_0 + v_60]; let [v_62]: [G; 1] = [G::from_u64(4)]; let [v_63]: [G; 1] = context.call::<1>(36, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_62, v_10])?; seed.full(24, v_63); let [v_64]: [G; 1] = context.store(37, &[v_59, v_61, v_63])?; seed.u32(32, v_64); Ok(()) }, _ => { let [v_65]: [G; 1] = [G::from_u64(0)]; let [v_66]: [G; 1] = [G::from_u64(255)]; let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75]: [G; 9] = context.call::<9>(40, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_65, v_65, v_65, v_65, v_66, v_66, v_66, v_66])?; seed.full(24, v_67); seed.u32(32, v_68); seed.u8(49, v_69); seed.u8(50, v_70); seed.u8(51, v_71); seed.u8(52, v_72); seed.u8(53, v_73); seed.u8(54, v_74); seed.u8(55, v_75); let [v_77]: [G; 1] = context.returned::<1>(42)?; seed.u32(36, v_77); Ok(()) }, } }, 3u64 => { let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79]: [G; 1] = [G::from_u64(3)]; let [v_80]: [G; 1] = [v_0 + v_79]; let [v_81]: [G; 1] = [G::from_u64(8)]; let [v_82]: [G; 1] = context.call::<1>(47, 36, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_81, v_10])?; seed.full(24, v_82); let [v_83]: [G; 1] = context.store(48, &[v_78, v_80, v_82])?; seed.u32(32, v_83); Ok(()) }, _ => { Err(no_match(41, v_1)) }, } } + +fn write_41(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [v_8 + v_9]; let [v_12]: [G; 1] = [v_7 + v_11]; let [v_13]: [G; 1] = [v_6 + v_12]; let [v_14]: [G; 1] = [v_5 + v_13]; let [v_15]: [G; 1] = [v_4 + v_14]; match v_15.as_canonical_u64() { 0u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_32.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 1u64 => { let [v_33]: [G; 1] = [v_8 + v_9]; let [v_34]: [G; 1] = [v_7 + v_33]; let [v_35]: [G; 1] = [v_6 + v_34]; let [v_36]: [G; 1] = [v_5 + v_35]; match v_36.as_canonical_u64() { 0u64 => { let [v_41]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_42.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_36 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_53.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_55.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 2u64 => { let [v_56]: [G; 1] = [v_8 + v_9]; let [v_57]: [G; 1] = [v_7 + v_56]; let [v_58]: [G; 1] = [v_6 + v_57]; match v_58.as_canonical_u64() { 0u64 => { let [v_63]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_64.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_58 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_75.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_77.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 3u64 => { let [v_82]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_83.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(41, v_1)) }, } } + +static SCHEMA_41: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 8, 40, 41, 42, 43, 44, 45, 46, 47, 48, 16, 24, 32, 49, 50, 51, 52, 53, 54, 55, 36], bytes: 56 }; + +fn pack_44(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_0.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, 1u64 => { break 'yield_0 []; }, 2u64 => { break 'yield_0 []; }, 3u64 => { break 'yield_0 []; }, _ => { return Err(no_match(44, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 43, &[v_1, v_2])?; seed[4] = v_9.as_canonical_u64(); Ok(()) }, } } + +fn pack_44_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_0.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, 1u64 => { break 'yield_0 []; }, 2u64 => { break 'yield_0 []; }, 3u64 => { break 'yield_0 []; }, _ => { return Err(no_match(44, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 43, &[v_1, v_2])?; seed.u8(11, v_9); Ok(()) }, } } + +fn write_44(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); match v_0.as_canonical_u64() { _ => { let [v_7]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, 1u64 => { let [v_4]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_4]; }, 2u64 => { let [v_5]: [G; 1] = [G::from_u64(2)]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_5]; }, 3u64 => { let [v_6]: [G; 1] = [G::from_u64(3)]; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_6]; }, _ => { return Err(no_match(44, v_0)); }, } }; row[offsets.auxiliaries + 1] = v_7.as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_9.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, } } + +static SCHEMA_44: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11], bytes: 16 }; + +fn pack_47(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; match v_0.as_canonical_u64() { 7u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_1)?; seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 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])?; seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_47_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; match v_0.as_canonical_u64() { 7u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_1)?; seed.u8(348, v_18); seed.u32(340, v_19); seed.full(144, v_20); seed.u8(349, v_21); seed.full(152, v_22); seed.full(160, v_23); seed.full(168, v_24); seed.full(176, v_25); seed.full(184, v_26); seed.u32(344, v_27); seed.full(192, v_28); seed.u8(350, v_29); seed.u8(351, v_30); seed.u8(352, v_31); seed.u8(353, v_32); seed.u8(354, v_33); seed.u8(355, v_34); seed.full(200, v_35); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 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])?; seed.full(208, v_36); seed.full(216, v_37); seed.full(224, v_38); seed.full(232, v_39); seed.full(240, v_40); seed.full(248, v_41); seed.full(256, v_42); seed.full(264, v_43); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed.full(272, v_44); seed.full(280, v_45); seed.full(288, v_46); seed.full(296, v_47); seed.full(304, v_48); seed.full(312, v_49); seed.full(320, v_50); seed.full(328, v_51); Ok(()) }, _ => { Ok(()) }, } } + +fn write_47(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); match v_0.as_canonical_u64() { 7u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = [G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44])]; row[offsets.auxiliaries + 19] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = [G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 27] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_51.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_47: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 336, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 348, 340, 144, 349, 152, 160, 168, 176, 184, 344, 192, 350, 351, 352, 353, 354, 355, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 328], bytes: 360 }; + +fn pack_48(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; match v_0.as_canonical_u64() { 8u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_5)?; seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 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])?; seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_48_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; match v_0.as_canonical_u64() { 8u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_5)?; seed.u8(348, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.u8(349, v_21); seed.full(160, v_22); seed.u32(340, v_23); seed.full(168, v_24); seed.full(176, v_25); seed.full(184, v_26); seed.u32(344, v_27); seed.full(192, v_28); seed.u8(350, v_29); seed.u8(351, v_30); seed.u8(352, v_31); seed.u8(353, v_32); seed.u8(354, v_33); seed.u8(355, v_34); seed.full(200, v_35); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 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])?; seed.full(208, v_36); seed.full(216, v_37); seed.full(224, v_38); seed.full(232, v_39); seed.full(240, v_40); seed.full(248, v_41); seed.full(256, v_42); seed.full(264, v_43); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed.full(272, v_44); seed.full(280, v_45); seed.full(288, v_46); seed.full(296, v_47); seed.full(304, v_48); seed.full(312, v_49); seed.full(320, v_50); seed.full(328, v_51); Ok(()) }, _ => { Ok(()) }, } } + +fn write_48(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); match v_0.as_canonical_u64() { 8u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = [G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44])]; row[offsets.auxiliaries + 19] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = [G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 27] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_51.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_48: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 24, 32, 40, 336, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 348, 144, 152, 349, 160, 340, 168, 176, 184, 344, 192, 350, 351, 352, 353, 354, 355, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 328], bytes: 360 }; + +fn pack_49(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; match v_0.as_canonical_u64() { 9u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_7)?; seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 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])?; seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_49_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; match v_0.as_canonical_u64() { 9u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_7)?; seed.u8(348, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.u8(349, v_21); seed.full(160, v_22); seed.full(168, v_23); seed.full(176, v_24); seed.u32(340, v_25); seed.full(184, v_26); seed.u32(344, v_27); seed.full(192, v_28); seed.u8(350, v_29); seed.u8(351, v_30); seed.u8(352, v_31); seed.u8(353, v_32); seed.u8(354, v_33); seed.u8(355, v_34); seed.full(200, v_35); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 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])?; seed.full(208, v_36); seed.full(216, v_37); seed.full(224, v_38); seed.full(232, v_39); seed.full(240, v_40); seed.full(248, v_41); seed.full(256, v_42); seed.full(264, v_43); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed.full(272, v_44); seed.full(280, v_45); seed.full(288, v_46); seed.full(296, v_47); seed.full(304, v_48); seed.full(312, v_49); seed.full(320, v_50); seed.full(328, v_51); Ok(()) }, _ => { Ok(()) }, } } + +fn write_49(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); match v_0.as_canonical_u64() { 9u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = [G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44])]; row[offsets.auxiliaries + 19] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = [G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 27] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_51.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(9)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_49: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 336, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 348, 144, 152, 349, 160, 168, 176, 340, 184, 344, 192, 350, 351, 352, 353, 354, 355, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 328], bytes: 360 }; + +fn pack_50(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; match v_0.as_canonical_u64() { 7u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = context.load::<18>(0, v_1)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_2)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = context.call::<1>(2, 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])?; seed[56] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.returned::<1>(3)?; seed[57] = v_56.as_canonical_u64(); Ok(()) }, _ => { let [v_57]: [G; 1] = context.returned::<1>(4)?; seed[20] = v_57.as_canonical_u64(); Ok(()) }, } } + +fn pack_50_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; match v_0.as_canonical_u64() { 7u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = context.load::<18>(0, v_1)?; seed.u32(20, v_19); seed.u8(57, v_20); seed.u8(58, v_21); seed.u8(59, v_22); seed.u8(60, v_23); seed.u8(61, v_24); seed.u8(62, v_25); seed.u8(63, v_26); seed.u8(64, v_27); seed.u8(65, v_28); seed.u8(66, v_29); seed.u8(67, v_30); seed.u8(68, v_31); seed.u8(69, v_32); seed.u8(70, v_33); seed.u8(71, v_34); seed.u8(72, v_35); seed.u32(24, v_36); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_2)?; seed.u8(73, v_37); seed.u8(74, v_38); seed.u8(75, v_39); seed.u8(76, v_40); seed.u8(77, v_41); seed.u8(78, v_42); seed.u8(79, v_43); seed.u8(80, v_44); seed.u8(81, v_45); seed.u8(82, v_46); seed.u8(83, v_47); seed.u8(84, v_48); seed.u8(85, v_49); seed.u8(86, v_50); seed.u8(87, v_51); seed.u8(88, v_52); seed.u8(89, v_53); seed.u32(28, v_54); let [v_55]: [G; 1] = context.call::<1>(2, 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])?; seed.u32(32, v_55); let [v_56]: [G; 1] = context.returned::<1>(3)?; seed.u32(36, v_56); Ok(()) }, _ => { let [v_57]: [G; 1] = context.returned::<1>(4)?; seed.u32(20, v_57); Ok(()) }, } } + +fn write_50(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); match v_0.as_canonical_u64() { 7u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 1] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 19] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 37] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 38] = v_56.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_57.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_50: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 16, 8, 20, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 24, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 28, 32, 36], bytes: 96 }; + +fn pack_51(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; match v_0.as_canonical_u64() { 8u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = context.load::<18>(0, v_4)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_5)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = context.call::<1>(2, 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])?; seed[56] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(3, 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])?; seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed[58] = v_57.as_canonical_u64(); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed[20] = v_58.as_canonical_u64(); Ok(()) }, } } + +fn pack_51_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; match v_0.as_canonical_u64() { 8u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = context.load::<18>(0, v_4)?; seed.u32(20, v_19); seed.u8(61, v_20); seed.u8(62, v_21); seed.u8(63, v_22); seed.u8(64, v_23); seed.u8(65, v_24); seed.u8(66, v_25); seed.u8(67, v_26); seed.u8(68, v_27); seed.u8(69, v_28); seed.u8(70, v_29); seed.u8(71, v_30); seed.u8(72, v_31); seed.u8(73, v_32); seed.u8(74, v_33); seed.u8(75, v_34); seed.u8(76, v_35); seed.u32(24, v_36); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_5)?; seed.u8(77, v_37); seed.u8(78, v_38); seed.u8(79, v_39); seed.u8(80, v_40); seed.u8(81, v_41); seed.u8(82, v_42); seed.u8(83, v_43); seed.u8(84, v_44); seed.u8(85, v_45); seed.u8(86, v_46); seed.u8(87, v_47); seed.u8(88, v_48); seed.u8(89, v_49); seed.u8(90, v_50); seed.u8(91, v_51); seed.u8(92, v_52); seed.u8(93, v_53); seed.u32(28, v_54); let [v_55]: [G; 1] = context.call::<1>(2, 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])?; seed.u32(32, v_55); let [v_56]: [G; 1] = context.call::<1>(3, 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])?; seed.u32(36, v_56); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed.u32(40, v_57); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed.u32(20, v_58); Ok(()) }, } } + +fn write_51(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); match v_0.as_canonical_u64() { 8u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 1] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 19] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 37] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 38] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 39] = v_57.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(8)).inverse().as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_58.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_51: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 16, 8, 20, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 24, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 28, 32, 36, 40], bytes: 96 }; + +fn pack_52(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; match v_0.as_canonical_u64() { 9u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = context.load::<18>(0, v_6)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_7)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = context.call::<1>(2, 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])?; seed[56] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(3, 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])?; seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed[58] = v_57.as_canonical_u64(); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed[20] = v_58.as_canonical_u64(); Ok(()) }, } } + +fn pack_52_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; match v_0.as_canonical_u64() { 9u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = context.load::<18>(0, v_6)?; seed.u32(20, v_19); seed.u8(61, v_20); seed.u8(62, v_21); seed.u8(63, v_22); seed.u8(64, v_23); seed.u8(65, v_24); seed.u8(66, v_25); seed.u8(67, v_26); seed.u8(68, v_27); seed.u8(69, v_28); seed.u8(70, v_29); seed.u8(71, v_30); seed.u8(72, v_31); seed.u8(73, v_32); seed.u8(74, v_33); seed.u8(75, v_34); seed.u8(76, v_35); seed.u32(24, v_36); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_7)?; seed.u8(77, v_37); seed.u8(78, v_38); seed.u8(79, v_39); seed.u8(80, v_40); seed.u8(81, v_41); seed.u8(82, v_42); seed.u8(83, v_43); seed.u8(84, v_44); seed.u8(85, v_45); seed.u8(86, v_46); seed.u8(87, v_47); seed.u8(88, v_48); seed.u8(89, v_49); seed.u8(90, v_50); seed.u8(91, v_51); seed.u8(92, v_52); seed.u8(93, v_53); seed.u32(28, v_54); let [v_55]: [G; 1] = context.call::<1>(2, 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])?; seed.u32(32, v_55); let [v_56]: [G; 1] = context.call::<1>(3, 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])?; seed.u32(36, v_56); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed.u32(40, v_57); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed.u32(20, v_58); Ok(()) }, } } + +fn write_52(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); match v_0.as_canonical_u64() { 9u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 18] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 1] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 19] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 37] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 38] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 39] = v_57.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(9)).inverse().as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_58.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_52: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 16, 8, 20, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 24, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 28, 32, 36, 40], bytes: 96 }; + +fn pack_55(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 8] = context.call::<8>(1, 55, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17])?; seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 8] = context.returned::<8>(2)?; seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_55_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; seed.full(72, v_9); seed.u32(268, v_10); seed.full(80, v_11); seed.full(88, v_12); seed.full(96, v_13); seed.full(104, v_14); seed.full(112, v_15); seed.full(120, v_16); seed.full(128, v_17); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 8] = context.call::<8>(1, 55, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17])?; seed.full(136, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.full(160, v_21); seed.full(168, v_22); seed.full(176, v_23); seed.full(184, v_24); seed.full(192, v_25); let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 8] = context.returned::<8>(2)?; seed.full(200, v_26); seed.full(208, v_27); seed.full(216, v_28); seed.full(224, v_29); seed.full(232, v_30); seed.full(240, v_31); seed.full(248, v_32); seed.full(256, v_33); Ok(()) }, _ => { Ok(()) }, } } + +fn write_55(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = [G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 8] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 8] = [G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_55: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 264, 16, 24, 32, 40, 48, 56, 64, 72, 268, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256], bytes: 272 }; + +fn pack_56(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 9] = context.returned::<9>(1)?; seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_56_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; seed.full(72, v_9); seed.u32(212, v_10); seed.full(80, v_11); seed.full(88, v_12); seed.full(96, v_13); seed.full(104, v_14); seed.full(112, v_15); seed.full(120, v_16); seed.full(128, v_17); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 9] = context.returned::<9>(1)?; seed.full(136, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.full(160, v_21); seed.full(168, v_22); seed.full(176, v_23); seed.full(184, v_24); seed.full(192, v_25); seed.full(200, v_26); Ok(()) }, _ => { Ok(()) }, } } + +fn write_56(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = [G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 9] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27])]; row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_56: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 208, 16, 24, 32, 40, 48, 56, 64, 72, 212, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200], bytes: 216 }; + +fn pack_57(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; match v_0.as_canonical_u64() { 0u64 => { let [v_10]: [G; 1] = [G::from_u64(0)]; let [v_11]: [G; 1] = context.store(1, &[v_10, v_10, v_9])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 55, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); seed[13] = v_14.as_canonical_u64(); seed[14] = v_15.as_canonical_u64(); seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 9] = context.call::<9>(3, 56, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); seed[23] = v_24.as_canonical_u64(); seed[24] = v_25.as_canonical_u64(); seed[25] = v_26.as_canonical_u64(); seed[26] = v_27.as_canonical_u64(); seed[27] = v_28.as_canonical_u64(); let [v_30]: [G; 1] = context.call::<1>(5, 57, &[v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_9])?; seed[28] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.returned::<1>(6)?; seed[29] = v_31.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40]: [G; 9] = context.load::<9>(7, v_1)?; seed[11] = v_32.as_canonical_u64(); seed[12] = v_33.as_canonical_u64(); seed[13] = v_34.as_canonical_u64(); seed[14] = v_35.as_canonical_u64(); seed[15] = v_36.as_canonical_u64(); seed[16] = v_37.as_canonical_u64(); seed[17] = v_38.as_canonical_u64(); seed[18] = v_39.as_canonical_u64(); seed[19] = v_40.as_canonical_u64(); let [v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 9] = context.load::<9>(8, v_2)?; seed[20] = v_41.as_canonical_u64(); seed[21] = v_42.as_canonical_u64(); seed[22] = v_43.as_canonical_u64(); seed[23] = v_44.as_canonical_u64(); seed[24] = v_45.as_canonical_u64(); seed[25] = v_46.as_canonical_u64(); seed[26] = v_47.as_canonical_u64(); seed[27] = v_48.as_canonical_u64(); seed[28] = v_49.as_canonical_u64(); let [v_52]: [G; 1] = context.call::<1>(11, 57, &[v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_9])?; seed[29] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = context.call::<1>(12, 57, &[v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_52])?; seed[30] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = context.returned::<1>(13)?; seed[31] = v_54.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 9] = context.load::<9>(14, v_1)?; seed[11] = v_55.as_canonical_u64(); seed[12] = v_56.as_canonical_u64(); seed[13] = v_57.as_canonical_u64(); seed[14] = v_58.as_canonical_u64(); seed[15] = v_59.as_canonical_u64(); seed[16] = v_60.as_canonical_u64(); seed[17] = v_61.as_canonical_u64(); seed[18] = v_62.as_canonical_u64(); seed[19] = v_63.as_canonical_u64(); let [v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 9] = context.load::<9>(15, v_2)?; seed[20] = v_64.as_canonical_u64(); seed[21] = v_65.as_canonical_u64(); seed[22] = v_66.as_canonical_u64(); seed[23] = v_67.as_canonical_u64(); seed[24] = v_68.as_canonical_u64(); seed[25] = v_69.as_canonical_u64(); seed[26] = v_70.as_canonical_u64(); seed[27] = v_71.as_canonical_u64(); seed[28] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(18, 57, &[v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_9])?; seed[29] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = context.call::<1>(19, 57, &[v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_75])?; seed[30] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = context.returned::<1>(20)?; seed[31] = v_77.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_79]: [G; 1] = context.returned::<1>(22)?; seed[11] = v_79.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(57, v_0)) }, } } + +fn pack_57_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; match v_0.as_canonical_u64() { 0u64 => { let [v_10]: [G; 1] = [G::from_u64(0)]; let [v_11]: [G; 1] = context.store(1, &[v_10, v_10, v_9])?; seed.u32(16, v_11); Ok(()) }, 1u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 55, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u32(16, v_12); seed.u8(45, v_13); seed.u8(46, v_14); seed.u8(47, v_15); seed.u8(48, v_16); seed.u8(49, v_17); seed.u8(50, v_18); seed.u8(51, v_19); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 9] = context.call::<9>(3, 56, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(52, v_20); seed.u8(53, v_21); seed.u8(54, v_22); seed.u8(55, v_23); seed.u8(56, v_24); seed.u8(57, v_25); seed.u8(58, v_26); seed.u8(59, v_27); seed.u8(60, v_28); let [v_30]: [G; 1] = context.call::<1>(5, 57, &[v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_9])?; seed.u32(20, v_30); let [v_31]: [G; 1] = context.returned::<1>(6)?; seed.u32(24, v_31); Ok(()) }, 2u64 => { let [v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40]: [G; 9] = context.load::<9>(7, v_1)?; seed.u32(16, v_32); seed.u8(45, v_33); seed.u8(46, v_34); seed.u8(47, v_35); seed.u8(48, v_36); seed.u8(49, v_37); seed.u8(50, v_38); seed.u8(51, v_39); seed.u8(52, v_40); let [v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 9] = context.load::<9>(8, v_2)?; seed.u8(53, v_41); seed.u8(54, v_42); seed.u8(55, v_43); seed.u8(56, v_44); seed.u8(57, v_45); seed.u8(58, v_46); seed.u8(59, v_47); seed.u8(60, v_48); seed.u32(20, v_49); let [v_52]: [G; 1] = context.call::<1>(11, 57, &[v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_9])?; seed.u32(24, v_52); let [v_53]: [G; 1] = context.call::<1>(12, 57, &[v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_52])?; seed.u32(28, v_53); let [v_54]: [G; 1] = context.returned::<1>(13)?; seed.u32(32, v_54); Ok(()) }, 3u64 => { let [v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 9] = context.load::<9>(14, v_1)?; seed.u32(16, v_55); seed.u8(45, v_56); seed.u8(46, v_57); seed.u8(47, v_58); seed.u8(48, v_59); seed.u8(49, v_60); seed.u8(50, v_61); seed.u8(51, v_62); seed.u8(52, v_63); let [v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 9] = context.load::<9>(15, v_2)?; seed.u8(53, v_64); seed.u8(54, v_65); seed.u8(55, v_66); seed.u8(56, v_67); seed.u8(57, v_68); seed.u8(58, v_69); seed.u8(59, v_70); seed.u8(60, v_71); seed.u32(20, v_72); let [v_75]: [G; 1] = context.call::<1>(18, 57, &[v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_9])?; seed.u32(24, v_75); let [v_76]: [G; 1] = context.call::<1>(19, 57, &[v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_75])?; seed.u32(28, v_76); let [v_77]: [G; 1] = context.returned::<1>(20)?; seed.u32(32, v_77); Ok(()) }, 4u64 => { let [v_79]: [G; 1] = context.returned::<1>(22)?; seed.u32(16, v_79); Ok(()) }, _ => { Err(no_match(57, v_0)) }, } } + +fn write_57(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); match v_0.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18])]; row[offsets.auxiliaries + 1] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_19.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 9] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27])]; row[offsets.auxiliaries + 9] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_28.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 18] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_31.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40]: [G; 9] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 1] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_40.as_canonical_u64(); let [v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 9] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 10] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_49.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 20] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 21] = v_54.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 9] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 1] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_63.as_canonical_u64(); let [v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 9] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 10] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 20] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 21] = v_77.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_79]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_79.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(57, v_0)) }, } } + +static SCHEMA_57: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 36, 37, 38, 39, 40, 41, 42, 43, 44, 8, 16, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 20, 24, 28, 32], bytes: 64 }; + +fn pack_62(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; match v_0.as_canonical_u64() { _ => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 18] = context.load::<18>(0, v_10)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 18] = context.load::<18>(1, v_11)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); let [v_49]: [G; 1] = context.call::<1>(2, 54, &[v_0, v_1])?; seed[50] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(0)]; let [v_51]: [G; 1] = context.call::<1>(4, 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])?; seed[51] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = context.call::<1>(5, 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])?; seed[52] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = context.call::<1>(6, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_52])?; seed[53] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = context.store(7, &[v_50, v_49, v_53])?; seed[54] = v_54.as_canonical_u64(); Ok(()) }, } } + +fn pack_62_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; match v_0.as_canonical_u64() { _ => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 18] = context.load::<18>(0, v_10)?; seed.u8(58, v_13); seed.u8(59, v_14); seed.u8(60, v_15); seed.u8(61, v_16); seed.u8(62, v_17); seed.u8(63, v_18); seed.u8(64, v_19); seed.u8(65, v_20); seed.u8(66, v_21); seed.u8(67, v_22); seed.u8(68, v_23); seed.u8(69, v_24); seed.u8(70, v_25); seed.u8(71, v_26); seed.u8(72, v_27); seed.u8(73, v_28); seed.u8(74, v_29); seed.u32(24, v_30); let [v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 18] = context.load::<18>(1, v_11)?; seed.u8(75, v_31); seed.u8(76, v_32); seed.u8(77, v_33); seed.u8(78, v_34); seed.u8(79, v_35); seed.u8(80, v_36); seed.u8(81, v_37); seed.u8(82, v_38); seed.u8(83, v_39); seed.u8(84, v_40); seed.u8(85, v_41); seed.u8(86, v_42); seed.u8(87, v_43); seed.u8(88, v_44); seed.u8(89, v_45); seed.u8(90, v_46); seed.u8(91, v_47); seed.u32(28, v_48); let [v_49]: [G; 1] = context.call::<1>(2, 54, &[v_0, v_1])?; seed.u8(92, v_49); let [v_50]: [G; 1] = [G::from_u64(0)]; let [v_51]: [G; 1] = context.call::<1>(4, 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])?; seed.u32(32, v_51); let [v_52]: [G; 1] = context.call::<1>(5, 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])?; seed.u32(36, v_52); let [v_53]: [G; 1] = context.call::<1>(6, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_52])?; seed.u32(40, v_53); let [v_54]: [G; 1] = context.store(7, &[v_50, v_49, v_53])?; seed.u32(44, v_54); Ok(()) }, } } + +fn write_62(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); match v_0.as_canonical_u64() { _ => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 18] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 1] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 18] = [G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 19] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_48.as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 37] = v_49.as_canonical_u64(); let [v_51]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 38] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 39] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 40] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 41] = v_54.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_62: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 16, 20, 8, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 24, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 28, 92, 32, 36, 40, 44], bytes: 96 }; + +fn pack_63(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; match v_0.as_canonical_u64() { _ => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 18] = context.load::<18>(0, v_8)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = context.call::<1>(1, 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])?; seed[29] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.returned::<1>(2)?; seed[30] = v_29.as_canonical_u64(); Ok(()) }, } } + +fn pack_63_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; match v_0.as_canonical_u64() { _ => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 18] = context.load::<18>(0, v_8)?; seed.u8(40, v_10); seed.u8(41, v_11); seed.u8(42, v_12); seed.u8(43, v_13); seed.u8(44, v_14); seed.u8(45, v_15); seed.u8(46, v_16); seed.u8(47, v_17); seed.u8(48, v_18); seed.u8(49, v_19); seed.u8(50, v_20); seed.u8(51, v_21); seed.u8(52, v_22); seed.u8(53, v_23); seed.u8(54, v_24); seed.u8(55, v_25); seed.u8(56, v_26); seed.u32(20, v_27); let [v_28]: [G; 1] = context.call::<1>(1, 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])?; seed.u32(24, v_28); let [v_29]: [G; 1] = context.returned::<1>(2)?; seed.u32(28, v_29); Ok(()) }, } } + +fn write_63(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); match v_0.as_canonical_u64() { _ => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 18] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 20] = v_29.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_63: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 32, 33, 34, 35, 36, 37, 38, 39, 16, 8, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 20, 24, 28], bytes: 64 }; + +fn pack_66(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(0)]; let [v_30]: [G; 1] = context.call::<1>(2, 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])?; seed[30] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(3, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_30])?; seed[31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.store(4, &[v_29, v_0, v_31])?; seed[32] = v_32.as_canonical_u64(); Ok(()) }, } } + +fn pack_66_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; seed.u8(52, v_11); seed.u8(53, v_12); seed.u8(54, v_13); seed.u8(55, v_14); seed.u8(56, v_15); seed.u8(57, v_16); seed.u8(58, v_17); seed.u8(59, v_18); seed.u8(60, v_19); seed.u8(61, v_20); seed.u8(62, v_21); seed.u8(63, v_22); seed.u8(64, v_23); seed.u8(65, v_24); seed.u8(66, v_25); seed.u8(67, v_26); seed.u8(68, v_27); seed.u32(28, v_28); let [v_29]: [G; 1] = [G::from_u64(0)]; let [v_30]: [G; 1] = context.call::<1>(2, 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])?; seed.u32(32, v_30); let [v_31]: [G; 1] = context.call::<1>(3, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_30])?; seed.u32(36, v_31); let [v_32]: [G; 1] = context.store(4, &[v_29, v_0, v_31])?; seed.u32(40, v_32); Ok(()) }, } } + +fn write_66(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_28.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 19] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 20] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 21] = v_32.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_66: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 44, 45, 46, 47, 48, 49, 50, 51, 24, 16, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 28, 32, 36, 40], bytes: 72 }; + +fn pack_67(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.call::<1>(1, 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])?; seed[30] = v_29.as_canonical_u64(); let [v_30]: [G; 1] = context.call::<1>(2, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_29])?; seed[31] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.returned::<1>(3)?; seed[32] = v_31.as_canonical_u64(); Ok(()) }, } } + +fn pack_67_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; seed.u8(45, v_11); seed.u8(46, v_12); seed.u8(47, v_13); seed.u8(48, v_14); seed.u8(49, v_15); seed.u8(50, v_16); seed.u8(51, v_17); seed.u8(52, v_18); seed.u8(53, v_19); seed.u8(54, v_20); seed.u8(55, v_21); seed.u8(56, v_22); seed.u8(57, v_23); seed.u8(58, v_24); seed.u8(59, v_25); seed.u8(60, v_26); seed.u8(61, v_27); seed.u32(20, v_28); let [v_29]: [G; 1] = context.call::<1>(1, 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])?; seed.u32(24, v_29); let [v_30]: [G; 1] = context.call::<1>(2, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_29])?; seed.u32(28, v_30); let [v_31]: [G; 1] = context.returned::<1>(3)?; seed.u32(32, v_31); Ok(()) }, } } + +fn write_67(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 19] = v_29.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 20] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 21] = v_31.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_67: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 36, 37, 38, 39, 40, 41, 42, 43, 44, 16, 8, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 20, 24, 28, 32], bytes: 64 }; + +fn pack_68(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; match v_0.as_canonical_u64() { _ => { let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 18] = context.load::<18>(0, v_33)?; seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(2, 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])?; seed[54] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = context.call::<1>(3, 39, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_54])?; seed[55] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(4, 39, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_55])?; seed[56] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.call::<1>(5, 39, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_56])?; seed[57] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.call::<1>(6, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_57])?; seed[58] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.store(7, &[v_53, v_0, v_58])?; seed[59] = v_59.as_canonical_u64(); Ok(()) }, } } + +fn pack_68_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; match v_0.as_canonical_u64() { _ => { let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 18] = context.load::<18>(0, v_33)?; seed.u8(88, v_35); seed.u8(89, v_36); seed.u8(90, v_37); seed.u8(91, v_38); seed.u8(92, v_39); seed.u8(93, v_40); seed.u8(94, v_41); seed.u8(95, v_42); seed.u8(96, v_43); seed.u8(97, v_44); seed.u8(98, v_45); seed.u8(99, v_46); seed.u8(100, v_47); seed.u8(101, v_48); seed.u8(102, v_49); seed.u8(103, v_50); seed.u8(104, v_51); seed.u32(28, v_52); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(2, 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])?; seed.u32(32, v_54); let [v_55]: [G; 1] = context.call::<1>(3, 39, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_54])?; seed.u32(36, v_55); let [v_56]: [G; 1] = context.call::<1>(4, 39, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_55])?; seed.u32(40, v_56); let [v_57]: [G; 1] = context.call::<1>(5, 39, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_56])?; seed.u32(44, v_57); let [v_58]: [G; 1] = context.call::<1>(6, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_57])?; seed.u32(48, v_58); let [v_59]: [G; 1] = context.store(7, &[v_53, v_0, v_58])?; seed.u32(52, v_59); Ok(()) }, } } + +fn write_68(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); match v_0.as_canonical_u64() { _ => { let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 18] = [G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53])]; row[offsets.auxiliaries + 1] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_52.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 19] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 20] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 21] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 22] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 23] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 24] = v_59.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_68: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 24, 16, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 28, 32, 36, 40, 44, 48, 52], bytes: 112 }; + +fn pack_69(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 36] = context.load::<36>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38]: [G; 1] = context.call::<1>(1, 69, &[v_37, v_1])?; seed[39] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.returned::<1>(2)?; seed[40] = v_39.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(69, v_2)) }, } } + +fn pack_69_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 36] = context.load::<36>(0, v_0)?; seed.u8(48, v_2); seed.full(16, v_3); seed.u8(49, v_4); seed.u8(50, v_5); seed.u8(51, v_6); seed.u8(52, v_7); seed.u8(53, v_8); seed.u8(54, v_9); seed.u8(55, v_10); seed.u8(56, v_11); seed.u8(57, v_12); seed.u8(58, v_13); seed.u8(59, v_14); seed.u8(60, v_15); seed.u8(61, v_16); seed.u8(62, v_17); seed.u8(63, v_18); seed.u8(64, v_19); seed.u8(65, v_20); seed.u8(66, v_21); seed.u8(67, v_22); seed.u8(68, v_23); seed.u8(69, v_24); seed.u8(70, v_25); seed.u8(71, v_26); seed.u8(72, v_27); seed.u8(73, v_28); seed.u8(74, v_29); seed.u8(75, v_30); seed.u8(76, v_31); seed.u8(77, v_32); seed.u8(78, v_33); seed.u8(79, v_34); seed.u8(80, v_35); seed.u32(36, v_36); seed.u32(40, v_37); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38]: [G; 1] = context.call::<1>(1, 69, &[v_37, v_1])?; seed.full(24, v_38); let [v_39]: [G; 1] = context.returned::<1>(2)?; seed.u32(44, v_39); Ok(()) }, _ => { Err(no_match(69, v_2)) }, } } + +fn write_69(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 36] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[40])]; row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(69, v_2)) }, } } + +static SCHEMA_69: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 32, 8, 48, 16, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 36, 40, 24, 44], bytes: 88 }; + +fn pack_70(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; match v_0.as_canonical_u64() { _ => { let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 18] = context.load::<18>(0, v_25)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.call::<8>(1, 791, &[v_26])?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(0)]; let [v_55]: [G; 1] = context.call::<1>(3, 69, &[v_26, v_27])?; seed[55] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(4, 39, &[v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_55])?; seed[56] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.call::<1>(5, 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])?; seed[57] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.call::<1>(6, 39, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_57])?; seed[58] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.call::<1>(7, 39, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_58])?; seed[59] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(8, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_59])?; seed[60] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = context.store(9, &[v_54, v_0, v_60])?; seed[61] = v_61.as_canonical_u64(); Ok(()) }, } } + +fn pack_70_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; match v_0.as_canonical_u64() { _ => { let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 18] = context.load::<18>(0, v_25)?; seed.u8(92, v_28); seed.u8(93, v_29); seed.u8(94, v_30); seed.u8(95, v_31); seed.u8(96, v_32); seed.u8(97, v_33); seed.u8(98, v_34); seed.u8(99, v_35); seed.u8(100, v_36); seed.u8(101, v_37); seed.u8(102, v_38); seed.u8(103, v_39); seed.u8(104, v_40); seed.u8(105, v_41); seed.u8(106, v_42); seed.u8(107, v_43); seed.u8(108, v_44); seed.u32(40, v_45); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.call::<8>(1, 791, &[v_26])?; seed.u8(109, v_46); seed.u8(110, v_47); seed.u8(111, v_48); seed.u8(112, v_49); seed.u8(113, v_50); seed.u8(114, v_51); seed.u8(115, v_52); seed.u8(116, v_53); let [v_54]: [G; 1] = [G::from_u64(0)]; let [v_55]: [G; 1] = context.call::<1>(3, 69, &[v_26, v_27])?; seed.full(24, v_55); let [v_56]: [G; 1] = context.call::<1>(4, 39, &[v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_55])?; seed.u32(44, v_56); let [v_57]: [G; 1] = context.call::<1>(5, 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])?; seed.u32(48, v_57); let [v_58]: [G; 1] = context.call::<1>(6, 39, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_57])?; seed.u32(52, v_58); let [v_59]: [G; 1] = context.call::<1>(7, 39, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_58])?; seed.u32(56, v_59); let [v_60]: [G; 1] = context.call::<1>(8, 39, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_59])?; seed.u32(60, v_60); let [v_61]: [G; 1] = context.store(9, &[v_54, v_0, v_60])?; seed.u32(64, v_61); Ok(()) }, } } + +fn write_70(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); match v_0.as_canonical_u64() { _ => { let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 18] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 1] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 19] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_53.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 27] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 28] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 29] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 30] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 31] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[60])]; row[offsets.auxiliaries + 32] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 33] = v_61.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_70: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 32, 36, 16, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 40, 109, 110, 111, 112, 113, 114, 115, 116, 24, 44, 48, 52, 56, 60, 64], bytes: 120 }; + +fn pack_73(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; match v_0.as_canonical_u64() { 0u64 => { let [v_46]: [G; 1] = [G::from_u64(0)]; let [v_47]: [G; 1] = context.call::<1>(1, 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])?; seed[47] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.store(2, &[v_46, v_46, v_47])?; seed[48] = v_48.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.call::<1>(5, 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])?; seed[47] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = context.store(6, &[v_49, v_50, v_51])?; seed[48] = v_52.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = [G::from_u64(2)]; let [v_55]: [G; 1] = context.call::<1>(9, 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])?; seed[47] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.store(10, &[v_53, v_54, v_55])?; seed[48] = v_56.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(73, v_0)) }, } } + +fn pack_73_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; match v_0.as_canonical_u64() { 0u64 => { let [v_46]: [G; 1] = [G::from_u64(0)]; let [v_47]: [G; 1] = context.call::<1>(1, 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])?; seed.u32(24, v_47); let [v_48]: [G; 1] = context.store(2, &[v_46, v_46, v_47])?; seed.u32(28, v_48); Ok(()) }, 1u64 => { let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.call::<1>(5, 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])?; seed.u32(24, v_51); let [v_52]: [G; 1] = context.store(6, &[v_49, v_50, v_51])?; seed.u32(28, v_52); Ok(()) }, 2u64 => { let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = [G::from_u64(2)]; let [v_55]: [G; 1] = context.call::<1>(9, 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])?; seed.u32(24, v_55); let [v_56]: [G; 1] = context.store(10, &[v_53, v_54, v_55])?; seed.u32(28, v_56); Ok(()) }, _ => { Err(no_match(73, v_0)) }, } } + +fn write_73(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); match v_0.as_canonical_u64() { 0u64 => { let [v_47]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 2] = v_48.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_51]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 2] = v_52.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_55]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 2] = v_56.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(73, v_0)) }, } } + +static SCHEMA_73: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 16, 20, 8, 24, 28], bytes: 80 }; + +fn pack_74(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 47] = context.load::<47>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_49]: [G; 1] = context.call::<1>(1, 74, &[v_48, v_1])?; seed[50] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = context.returned::<1>(2)?; seed[51] = v_50.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(74, v_2)) }, } } + +fn pack_74_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 47] = context.load::<47>(0, v_0)?; seed.u8(44, v_2); seed.u8(45, v_3); seed.u8(46, v_4); seed.u8(47, v_5); seed.u8(48, v_6); seed.u8(49, v_7); seed.u8(50, v_8); seed.u8(51, v_9); seed.u8(52, v_10); seed.u8(53, v_11); seed.u8(54, v_12); seed.u8(55, v_13); seed.u8(56, v_14); seed.u8(57, v_15); seed.u8(58, v_16); seed.u8(59, v_17); seed.u8(60, v_18); seed.u8(61, v_19); seed.u8(62, v_20); seed.u8(63, v_21); seed.u8(64, v_22); seed.u8(65, v_23); seed.u8(66, v_24); seed.u8(67, v_25); seed.u8(68, v_26); seed.u8(69, v_27); seed.u8(70, v_28); seed.u8(71, v_29); seed.u8(72, v_30); seed.u8(73, v_31); seed.u8(74, v_32); seed.u8(75, v_33); seed.u8(76, v_34); seed.u8(77, v_35); seed.u8(78, v_36); seed.u8(79, v_37); seed.u8(80, v_38); seed.u8(81, v_39); seed.u8(82, v_40); seed.u8(83, v_41); seed.u8(84, v_42); seed.u8(85, v_43); seed.u8(86, v_44); seed.u8(87, v_45); seed.u32(28, v_46); seed.u32(32, v_47); seed.u32(36, v_48); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_49]: [G; 1] = context.call::<1>(1, 74, &[v_48, v_1])?; seed.full(16, v_49); let [v_50]: [G; 1] = context.returned::<1>(2)?; seed.u32(40, v_50); Ok(()) }, _ => { Err(no_match(74, v_2)) }, } } + +fn write_74(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 47] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_49]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(74, v_2)) }, } } + +static SCHEMA_74: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 24, 8, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 28, 32, 36, 16, 40], bytes: 88 }; + +fn pack_80(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); Ok(()) } + +fn pack_80_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(28, v_1); seed.full(8, v_2); seed.full(16, v_3); Ok(()) } + +fn write_80(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(80, v_1)) }, } } + +static SCHEMA_80: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 24, 28, 8, 16], bytes: 32 }; + +fn pack_81(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_0)?; seed[3] = v_3.as_canonical_u64(); seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [v_1 - v_6]; let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = context.call::<9>(4, 81, &[v_5, v_7])?; seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(81, v_3)) }, } }, } } + +fn pack_81_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_0)?; seed.u8(104, v_3); seed.full(16, v_4); seed.u32(100, v_5); match v_3.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [v_1 - v_6]; let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = context.call::<9>(4, 81, &[v_5, v_7])?; seed.full(24, v_8); seed.full(32, v_9); seed.full(40, v_10); seed.full(48, v_11); seed.full(56, v_12); seed.full(64, v_13); seed.full(72, v_14); seed.full(80, v_15); seed.full(88, v_16); Ok(()) }, _ => { Err(no_match(81, v_3)) }, } }, } } + +fn write_81(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 9] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(81, v_3)) }, } }, } } + +static SCHEMA_81: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 96, 8, 104, 16, 100, 24, 32, 40, 48, 56, 64, 72, 80, 88], bytes: 112 }; + +fn pack_82(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_14 * v_6]; let [v_23]: [G; 1] = [v_21 + v_22]; let [v_24]: [G; 1] = [v_4 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_26]: [G; 1] = [G::from_u64(4)]; let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 9] = context.call::<9>(17, 85, &[v_24, v_26, v_3])?; seed[5] = v_27.as_canonical_u64(); seed[6] = v_28.as_canonical_u64(); seed[7] = v_29.as_canonical_u64(); seed[8] = v_30.as_canonical_u64(); seed[9] = v_31.as_canonical_u64(); seed[10] = v_32.as_canonical_u64(); seed[11] = v_33.as_canonical_u64(); seed[12] = v_34.as_canonical_u64(); seed[13] = v_35.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(82, v_7)) }, } }, _ => { Err(no_match(82, v_1)) }, } } + +fn pack_82_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_1); seed.u8(33, v_2); seed.u32(28, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_14 * v_6]; let [v_23]: [G; 1] = [v_21 + v_22]; let [v_24]: [G; 1] = [v_4 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_26]: [G; 1] = [G::from_u64(4)]; let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 9] = context.call::<9>(17, 85, &[v_24, v_26, v_3])?; seed.u8(34, v_27); seed.full(8, v_28); seed.u8(35, v_29); seed.u8(36, v_30); seed.u8(37, v_31); seed.u8(38, v_32); seed.u8(39, v_33); seed.u8(40, v_34); seed.full(16, v_35); Ok(()) }, _ => { Err(no_match(82, v_7)) }, } }, _ => { Err(no_match(82, v_1)) }, } } + +fn write_82(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 8] = [G::from_bool((v_2.as_canonical_u64() & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_2.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 9] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 12] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_35.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(82, v_7)) }, } }, _ => { Err(no_match(82, v_1)) }, } } + +static SCHEMA_82: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 32, 33, 28, 34, 8, 35, 36, 37, 38, 39, 40, 16], bytes: 48 }; + +fn pack_84(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4]: [G; 1] = [G::from_u64(128)]; let [v_5]: [G; 1] = [Bytes2::less_than(&v_2, &v_4)]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 9] = context.returned::<9>(7)?; seed[5] = v_10.as_canonical_u64(); seed[6] = v_11.as_canonical_u64(); seed[7] = v_12.as_canonical_u64(); seed[8] = v_13.as_canonical_u64(); seed[9] = v_14.as_canonical_u64(); seed[10] = v_15.as_canonical_u64(); seed[11] = v_16.as_canonical_u64(); seed[12] = v_17.as_canonical_u64(); seed[13] = v_18.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(84, v_5)) }, } }, _ => { Err(no_match(84, v_1)) }, } } + +fn pack_84_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_1); seed.u8(33, v_2); seed.u32(28, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4]: [G; 1] = [G::from_u64(128)]; let [v_5]: [G; 1] = [Bytes2::less_than(&v_2, &v_4)]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 9] = context.returned::<9>(7)?; seed.u8(34, v_10); seed.full(8, v_11); seed.u8(35, v_12); seed.u8(36, v_13); seed.u8(37, v_14); seed.u8(38, v_15); seed.u8(39, v_16); seed.u8(40, v_17); seed.full(16, v_18); Ok(()) }, _ => { Err(no_match(84, v_5)) }, } }, _ => { Err(no_match(84, v_1)) }, } } + +fn write_84(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4]: [G; 1] = [G::from_u64(128)]; let [v_5]: [G; 1] = [Bytes2::less_than(&v_2, &v_4)]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 9] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(84, v_5)) }, } }, _ => { Err(no_match(84, v_1)) }, } } + +static SCHEMA_84: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 32, 33, 28, 34, 8, 35, 36, 37, 38, 39, 40, 16], bytes: 48 }; + +fn pack_85(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = [Bytes2::less_than(&v_0, &v_1)]; match v_3.as_canonical_u64() { 1u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_2)?; seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); seed[6] = v_6.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 9] = context.returned::<9>(8)?; seed[4] = v_14.as_canonical_u64(); seed[5] = v_15.as_canonical_u64(); seed[6] = v_16.as_canonical_u64(); seed[7] = v_17.as_canonical_u64(); seed[8] = v_18.as_canonical_u64(); seed[9] = v_19.as_canonical_u64(); seed[10] = v_20.as_canonical_u64(); seed[11] = v_21.as_canonical_u64(); seed[12] = v_22.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_3)) }, } } + +fn pack_85_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = [Bytes2::less_than(&v_0, &v_1)]; match v_3.as_canonical_u64() { 1u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_2)?; seed.u8(30, v_4); seed.u8(31, v_5); seed.full(8, v_6); Ok(()) }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 9] = context.returned::<9>(8)?; seed.u8(30, v_14); seed.u8(31, v_15); seed.full(8, v_16); seed.u8(32, v_17); seed.u8(33, v_18); seed.u8(34, v_19); seed.u8(35, v_20); seed.u8(36, v_21); seed.full(16, v_22); Ok(()) }, _ => { Err(no_match(85, v_3)) }, } } + +fn write_85(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [Bytes2::less_than(&v_0, &v_1)]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [v_7 * v_1]; let op_4 = Bytes2::add(&v_5, &v_8); let [v_9, v_10]: [G; 2] = [op_4.0, op_4.1]; row[offsets.auxiliaries + 5] = v_9.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_4)) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 9] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 2] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_22.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_3)) }, } } + +static SCHEMA_85: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 28, 29, 24, 30, 31, 8, 32, 33, 34, 35, 36, 16], bytes: 40 }; + +fn pack_86(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = [G::from_u64(2)]; let [v_4]: [G; 1] = [v_3 * v_1]; match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = [G::from_u64(2)]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 9] = context.call::<9>(3, 81, &[v_2, v_5])?; seed[4] = v_6.as_canonical_u64(); seed[5] = v_7.as_canonical_u64(); seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(5, 15, &[v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_4, v_1, v_15, v_15, v_15, v_15, v_15, v_15])?; seed[13] = v_16.as_canonical_u64(); seed[14] = v_17.as_canonical_u64(); seed[15] = v_18.as_canonical_u64(); seed[16] = v_19.as_canonical_u64(); seed[17] = v_20.as_canonical_u64(); seed[18] = v_21.as_canonical_u64(); seed[19] = v_22.as_canonical_u64(); seed[20] = v_23.as_canonical_u64(); seed[21] = v_24.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_25]: [G; 1] = [G::from_u64(3)]; let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 9] = context.call::<9>(7, 81, &[v_2, v_25])?; seed[4] = v_26.as_canonical_u64(); seed[5] = v_27.as_canonical_u64(); seed[6] = v_28.as_canonical_u64(); seed[7] = v_29.as_canonical_u64(); seed[8] = v_30.as_canonical_u64(); seed[9] = v_31.as_canonical_u64(); seed[10] = v_32.as_canonical_u64(); seed[11] = v_33.as_canonical_u64(); seed[12] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = [G::from_u64(0)]; let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 9] = context.call::<9>(10, 15, &[v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_4, v_1, v_35, v_36, v_36, v_36, v_36, v_36])?; seed[13] = v_37.as_canonical_u64(); seed[14] = v_38.as_canonical_u64(); seed[15] = v_39.as_canonical_u64(); seed[16] = v_40.as_canonical_u64(); seed[17] = v_41.as_canonical_u64(); seed[18] = v_42.as_canonical_u64(); seed[19] = v_43.as_canonical_u64(); seed[20] = v_44.as_canonical_u64(); seed[21] = v_45.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_46]: [G; 1] = [G::from_u64(4)]; let [v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 9] = context.call::<9>(12, 81, &[v_2, v_46])?; seed[4] = v_47.as_canonical_u64(); seed[5] = v_48.as_canonical_u64(); seed[6] = v_49.as_canonical_u64(); seed[7] = v_50.as_canonical_u64(); seed[8] = v_51.as_canonical_u64(); seed[9] = v_52.as_canonical_u64(); seed[10] = v_53.as_canonical_u64(); seed[11] = v_54.as_canonical_u64(); seed[12] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(1)]; let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66]: [G; 9] = context.call::<9>(15, 15, &[v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_4, v_1, v_56, v_56, v_57, v_57, v_57, v_57])?; seed[13] = v_58.as_canonical_u64(); seed[14] = v_59.as_canonical_u64(); seed[15] = v_60.as_canonical_u64(); seed[16] = v_61.as_canonical_u64(); seed[17] = v_62.as_canonical_u64(); seed[18] = v_63.as_canonical_u64(); seed[19] = v_64.as_canonical_u64(); seed[20] = v_65.as_canonical_u64(); seed[21] = v_66.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_67]: [G; 1] = [G::from_u64(8)]; let [v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76]: [G; 9] = context.call::<9>(17, 81, &[v_2, v_67])?; seed[4] = v_68.as_canonical_u64(); seed[5] = v_69.as_canonical_u64(); seed[6] = v_70.as_canonical_u64(); seed[7] = v_71.as_canonical_u64(); seed[8] = v_72.as_canonical_u64(); seed[9] = v_73.as_canonical_u64(); seed[10] = v_74.as_canonical_u64(); seed[11] = v_75.as_canonical_u64(); seed[12] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(1)]; let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87]: [G; 9] = context.call::<9>(20, 15, &[v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_4, v_1, v_77, v_77, v_77, v_78, v_78, v_78])?; seed[13] = v_79.as_canonical_u64(); seed[14] = v_80.as_canonical_u64(); seed[15] = v_81.as_canonical_u64(); seed[16] = v_82.as_canonical_u64(); seed[17] = v_83.as_canonical_u64(); seed[18] = v_84.as_canonical_u64(); seed[19] = v_85.as_canonical_u64(); seed[20] = v_86.as_canonical_u64(); seed[21] = v_87.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(86, v_0)) }, } } + +fn pack_86_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = [G::from_u64(2)]; let [v_4]: [G; 1] = [v_3 * v_1]; match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = [G::from_u64(2)]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 9] = context.call::<9>(3, 81, &[v_2, v_5])?; seed.u8(22, v_6); seed.u8(23, v_7); seed.u8(24, v_8); seed.u8(25, v_9); seed.u8(26, v_10); seed.u8(27, v_11); seed.u8(28, v_12); seed.u8(29, v_13); seed.full(8, v_14); let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(5, 15, &[v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_4, v_1, v_15, v_15, v_15, v_15, v_15, v_15])?; seed.u8(30, v_16); seed.u8(31, v_17); seed.u8(32, v_18); seed.u8(33, v_19); seed.u8(34, v_20); seed.u8(35, v_21); seed.u8(36, v_22); seed.u8(37, v_23); seed.u8(38, v_24); Ok(()) }, 1u64 => { let [v_25]: [G; 1] = [G::from_u64(3)]; let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 9] = context.call::<9>(7, 81, &[v_2, v_25])?; seed.u8(22, v_26); seed.u8(23, v_27); seed.u8(24, v_28); seed.u8(25, v_29); seed.u8(26, v_30); seed.u8(27, v_31); seed.u8(28, v_32); seed.u8(29, v_33); seed.full(8, v_34); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = [G::from_u64(0)]; let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 9] = context.call::<9>(10, 15, &[v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_4, v_1, v_35, v_36, v_36, v_36, v_36, v_36])?; seed.u8(30, v_37); seed.u8(31, v_38); seed.u8(32, v_39); seed.u8(33, v_40); seed.u8(34, v_41); seed.u8(35, v_42); seed.u8(36, v_43); seed.u8(37, v_44); seed.u8(38, v_45); Ok(()) }, 2u64 => { let [v_46]: [G; 1] = [G::from_u64(4)]; let [v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 9] = context.call::<9>(12, 81, &[v_2, v_46])?; seed.u8(22, v_47); seed.u8(23, v_48); seed.u8(24, v_49); seed.u8(25, v_50); seed.u8(26, v_51); seed.u8(27, v_52); seed.u8(28, v_53); seed.u8(29, v_54); seed.full(8, v_55); let [v_56]: [G; 1] = [G::from_u64(1)]; let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66]: [G; 9] = context.call::<9>(15, 15, &[v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_4, v_1, v_56, v_56, v_57, v_57, v_57, v_57])?; seed.u8(30, v_58); seed.u8(31, v_59); seed.u8(32, v_60); seed.u8(33, v_61); seed.u8(34, v_62); seed.u8(35, v_63); seed.u8(36, v_64); seed.u8(37, v_65); seed.u8(38, v_66); Ok(()) }, 3u64 => { let [v_67]: [G; 1] = [G::from_u64(8)]; let [v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76]: [G; 9] = context.call::<9>(17, 81, &[v_2, v_67])?; seed.u8(22, v_68); seed.u8(23, v_69); seed.u8(24, v_70); seed.u8(25, v_71); seed.u8(26, v_72); seed.u8(27, v_73); seed.u8(28, v_74); seed.u8(29, v_75); seed.full(8, v_76); let [v_77]: [G; 1] = [G::from_u64(1)]; let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87]: [G; 9] = context.call::<9>(20, 15, &[v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_4, v_1, v_77, v_77, v_77, v_78, v_78, v_78])?; seed.u8(30, v_79); seed.u8(31, v_80); seed.u8(32, v_81); seed.u8(33, v_82); seed.u8(34, v_83); seed.u8(35, v_84); seed.u8(36, v_85); seed.u8(37, v_86); seed.u8(38, v_87); Ok(()) }, _ => { Err(no_match(86, v_0)) }, } } + +fn write_86(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); match v_0.as_canonical_u64() { 0u64 => { let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 9] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21])]; row[offsets.auxiliaries + 10] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_24.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 9] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_34.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 9] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21])]; row[offsets.auxiliaries + 10] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_45.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 9] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_55.as_canonical_u64(); let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66]: [G; 9] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21])]; row[offsets.auxiliaries + 10] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_66.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76]: [G; 9] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_76.as_canonical_u64(); let [v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87]: [G; 9] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21])]; row[offsets.auxiliaries + 10] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_87.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(86, v_0)) }, } } + +static SCHEMA_86: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 20, 21, 16, 22, 23, 24, 25, 26, 27, 28, 29, 8, 30, 31, 32, 33, 34, 35, 36, 37, 38], bytes: 40 }; + +fn pack_88(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = context.call::<1>(0, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[11] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = context.call::<2>(1, 95, &[v_1])?; seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(7)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(4, &[v_13, v_0, v_11, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed[14] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = context.call::<8>(5, 17, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); let [v_24, v_25]: [G; 2] = context.returned::<2>(6)?; seed[23] = v_24.as_canonical_u64(); seed[24] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(88, v_10)) }, } } + +fn pack_88_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10]: [G; 1] = context.call::<1>(0, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.u8(180, v_10); match v_10.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = context.call::<2>(1, 95, &[v_1])?; seed.full(80, v_11); seed.u32(172, v_12); let [v_13]: [G; 1] = [G::from_u64(7)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(4, &[v_13, v_0, v_11, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed.u32(176, v_15); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = context.call::<8>(5, 17, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(88, v_16); seed.full(96, v_17); seed.full(104, v_18); seed.full(112, v_19); seed.full(120, v_20); seed.full(128, v_21); seed.full(136, v_22); seed.full(144, v_23); let [v_24, v_25]: [G; 2] = context.returned::<2>(6)?; seed.full(152, v_24); seed.full(160, v_25); Ok(()) }, _ => { Err(no_match(88, v_10)) }, } } + +fn write_88(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let [v_10]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 4] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 8] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_23.as_canonical_u64(); let [v_24, v_25]: [G; 2] = [G::from_u64(seed[23]), G::from_u64(seed[24])]; row[offsets.auxiliaries + 13] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_25.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(88, v_10)) }, } } + +static SCHEMA_88: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 168, 16, 24, 32, 40, 48, 56, 64, 72, 180, 80, 172, 176, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160], bytes: 184 }; + +fn pack_91(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 80, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_15, v_16, v_17]: [G; 3] = context.call::<3>(7, 90, &[v_3, v_4, v_5, v_6])?; seed[4] = v_15.as_canonical_u64(); seed[5] = v_16.as_canonical_u64(); seed[6] = v_17.as_canonical_u64(); Ok(()) } + +fn pack_91_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 80, &[v_0])?; seed.u8(20, v_1); seed.full(8, v_2); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_15, v_16, v_17]: [G; 3] = context.call::<3>(7, 90, &[v_3, v_4, v_5, v_6])?; seed.u8(21, v_15); seed.u8(22, v_16); seed.u8(23, v_17); Ok(()) } + +fn write_91(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2]: [G; 2] = [G::from_u64(seed[2]), G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_15, v_16, v_17]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 11] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_91: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 16, 20, 8, 21, 22, 23], bytes: 24 }; + +fn pack_92(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 80, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_13, v_14, v_15]: [G; 3] = context.call::<3>(5, 90, &[v_3, v_4, v_5, v_6])?; seed[4] = v_13.as_canonical_u64(); seed[5] = v_14.as_canonical_u64(); seed[6] = v_15.as_canonical_u64(); let [v_16, v_17]: [G; 2] = context.call::<2>(6, 89, &[v_7, v_8])?; seed[7] = v_16.as_canonical_u64(); seed[8] = v_17.as_canonical_u64(); Ok(()) } + +fn pack_92_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 80, &[v_0])?; seed.u8(20, v_1); seed.full(8, v_2); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; let [v_13, v_14, v_15]: [G; 3] = context.call::<3>(5, 90, &[v_3, v_4, v_5, v_6])?; seed.u8(21, v_13); seed.u8(22, v_14); seed.u8(23, v_15); let [v_16, v_17]: [G; 2] = context.call::<2>(6, 89, &[v_7, v_8])?; seed.u8(24, v_16); seed.u8(25, v_17); Ok(()) } + +fn write_92(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2]: [G; 2] = [G::from_u64(seed[2]), G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 8] = [G::from_bool((v_1.as_canonical_u64() & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_1.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); let [v_16, v_17]: [G; 2] = [G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_92: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 16, 20, 8, 21, 22, 23, 24, 25], bytes: 32 }; + +fn pack_95(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.call::<10>(0, 82, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed[12] = v_12.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(1)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(5, &[v_13, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed[12] = v_15.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(6, 84, &[v_10])?; seed[12] = v_16.as_canonical_u64(); seed[13] = v_17.as_canonical_u64(); seed[14] = v_18.as_canonical_u64(); seed[15] = v_19.as_canonical_u64(); seed[16] = v_20.as_canonical_u64(); seed[17] = v_21.as_canonical_u64(); seed[18] = v_22.as_canonical_u64(); seed[19] = v_23.as_canonical_u64(); seed[20] = v_24.as_canonical_u64(); let [v_25, v_26]: [G; 2] = context.call::<2>(7, 87, &[v_24, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[21] = v_25.as_canonical_u64(); seed[22] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [G::from_u64(0)]; let [v_29]: [G; 1] = context.store(10, &[v_27, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_25, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed[23] = v_29.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = context.call::<9>(11, 84, &[v_10])?; seed[12] = v_30.as_canonical_u64(); seed[13] = v_31.as_canonical_u64(); seed[14] = v_32.as_canonical_u64(); seed[15] = v_33.as_canonical_u64(); seed[16] = v_34.as_canonical_u64(); seed[17] = v_35.as_canonical_u64(); seed[18] = v_36.as_canonical_u64(); seed[19] = v_37.as_canonical_u64(); seed[20] = v_38.as_canonical_u64(); let [v_39, v_40]: [G; 2] = context.call::<2>(12, 87, &[v_38, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[21] = v_39.as_canonical_u64(); seed[22] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(3)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(15, &[v_41, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_39, v_42, v_42, v_42, v_42, v_42, v_42, v_42, v_42])?; seed[23] = v_43.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = context.call::<9>(16, 84, &[v_10])?; seed[12] = v_44.as_canonical_u64(); seed[13] = v_45.as_canonical_u64(); seed[14] = v_46.as_canonical_u64(); seed[15] = v_47.as_canonical_u64(); seed[16] = v_48.as_canonical_u64(); seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); let [v_53, v_54]: [G; 2] = context.call::<2>(17, 95, &[v_52])?; seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(4)]; let [v_56]: [G; 1] = context.store(19, &[v_55, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_53])?; seed[23] = v_56.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_57]: [G; 1] = [G::from_u64(5)]; let [v_58]: [G; 1] = [G::from_u64(0)]; let [v_59]: [G; 1] = context.store(22, &[v_57, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58])?; seed[12] = v_59.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_60]: [G; 1] = [G::from_u64(6)]; let [v_61]: [G; 1] = [G::from_u64(0)]; let [v_62]: [G; 1] = context.store(25, &[v_60, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61])?; seed[12] = v_62.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = context.call::<1>(26, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_63.as_canonical_u64(); let [v_65, v_66]: [G; 2] = context.call::<2>(29, 95, &[v_10])?; seed[13] = v_65.as_canonical_u64(); seed[14] = v_66.as_canonical_u64(); let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84]: [G; 18] = context.load::<18>(30, v_65)?; seed[15] = v_67.as_canonical_u64(); seed[16] = v_68.as_canonical_u64(); seed[17] = v_69.as_canonical_u64(); seed[18] = v_70.as_canonical_u64(); seed[19] = v_71.as_canonical_u64(); seed[20] = v_72.as_canonical_u64(); seed[21] = v_73.as_canonical_u64(); seed[22] = v_74.as_canonical_u64(); seed[23] = v_75.as_canonical_u64(); seed[24] = v_76.as_canonical_u64(); seed[25] = v_77.as_canonical_u64(); seed[26] = v_78.as_canonical_u64(); seed[27] = v_79.as_canonical_u64(); seed[28] = v_80.as_canonical_u64(); seed[29] = v_81.as_canonical_u64(); seed[30] = v_82.as_canonical_u64(); seed[31] = v_83.as_canonical_u64(); seed[32] = v_84.as_canonical_u64(); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = context.returned::<2>(34)?; seed[33] = v_87.as_canonical_u64(); seed[34] = v_88.as_canonical_u64(); Ok(()) }, _ => { let [v_89, v_90]: [G; 2] = context.returned::<2>(35)?; seed[33] = v_89.as_canonical_u64(); seed[34] = v_90.as_canonical_u64(); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = context.call::<1>(36, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_91.as_canonical_u64(); let [v_93, v_94]: [G; 2] = context.returned::<2>(39)?; seed[13] = v_93.as_canonical_u64(); seed[14] = v_94.as_canonical_u64(); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = context.call::<1>(40, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[12] = v_95.as_canonical_u64(); let [v_97, v_98]: [G; 2] = context.returned::<2>(43)?; seed[13] = v_97.as_canonical_u64(); seed[14] = v_98.as_canonical_u64(); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = context.returned::<2>(44)?; seed[12] = v_99.as_canonical_u64(); seed[13] = v_100.as_canonical_u64(); Ok(()) }, 11u64 => { let [v_101]: [G; 1] = [G::from_u64(11)]; let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.store(47, &[v_101, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102])?; seed[12] = v_103.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(95, v_1)) }, } } + +fn pack_95_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.call::<10>(0, 82, &[v_0])?; seed.u8(140, v_1); seed.u8(141, v_2); seed.full(8, v_3); seed.u8(142, v_4); seed.u8(143, v_5); seed.u8(144, v_6); seed.u8(145, v_7); seed.u8(146, v_8); seed.u8(147, v_9); seed.u32(132, v_10); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed.full(16, v_12); Ok(()) }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(1)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(5, &[v_13, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14, v_14])?; seed.full(16, v_15); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(6, 84, &[v_10])?; seed.full(16, v_16); seed.full(24, v_17); seed.full(32, v_18); seed.u8(148, v_19); seed.full(40, v_20); seed.full(48, v_21); seed.u8(149, v_22); seed.full(56, v_23); seed.full(64, v_24); let [v_25, v_26]: [G; 2] = context.call::<2>(7, 87, &[v_24, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(72, v_25); seed.full(80, v_26); let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [G::from_u64(0)]; let [v_29]: [G; 1] = context.store(10, &[v_27, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_25, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed.full(88, v_29); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = context.call::<9>(11, 84, &[v_10])?; seed.full(16, v_30); seed.full(24, v_31); seed.full(32, v_32); seed.u8(148, v_33); seed.full(40, v_34); seed.full(48, v_35); seed.u8(149, v_36); seed.full(56, v_37); seed.full(64, v_38); let [v_39, v_40]: [G; 2] = context.call::<2>(12, 87, &[v_38, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(72, v_39); seed.full(80, v_40); let [v_41]: [G; 1] = [G::from_u64(3)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(15, &[v_41, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_39, v_42, v_42, v_42, v_42, v_42, v_42, v_42, v_42])?; seed.full(88, v_43); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = context.call::<9>(16, 84, &[v_10])?; seed.full(16, v_44); seed.full(24, v_45); seed.full(32, v_46); seed.u8(148, v_47); seed.full(40, v_48); seed.full(48, v_49); seed.u8(149, v_50); seed.full(56, v_51); seed.full(64, v_52); let [v_53, v_54]: [G; 2] = context.call::<2>(17, 95, &[v_52])?; seed.full(72, v_53); seed.full(80, v_54); let [v_55]: [G; 1] = [G::from_u64(4)]; let [v_56]: [G; 1] = context.store(19, &[v_55, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_53])?; seed.full(88, v_56); Ok(()) }, 5u64 => { let [v_57]: [G; 1] = [G::from_u64(5)]; let [v_58]: [G; 1] = [G::from_u64(0)]; let [v_59]: [G; 1] = context.store(22, &[v_57, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58, v_58])?; seed.full(16, v_59); Ok(()) }, 6u64 => { let [v_60]: [G; 1] = [G::from_u64(6)]; let [v_61]: [G; 1] = [G::from_u64(0)]; let [v_62]: [G; 1] = context.store(25, &[v_60, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61])?; seed.full(16, v_62); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = context.call::<1>(26, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(16, v_63); let [v_65, v_66]: [G; 2] = context.call::<2>(29, 95, &[v_10])?; seed.full(24, v_65); seed.full(32, v_66); let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84]: [G; 18] = context.load::<18>(30, v_65)?; seed.u8(148, v_67); seed.full(40, v_68); seed.full(48, v_69); seed.u8(149, v_70); seed.full(56, v_71); seed.full(64, v_72); seed.full(72, v_73); seed.full(80, v_74); seed.full(88, v_75); seed.u32(136, v_76); seed.full(96, v_77); seed.u8(150, v_78); seed.u8(151, v_79); seed.u8(152, v_80); seed.u8(153, v_81); seed.u8(154, v_82); seed.u8(155, v_83); seed.full(104, v_84); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = context.returned::<2>(34)?; seed.full(112, v_87); seed.full(120, v_88); Ok(()) }, _ => { let [v_89, v_90]: [G; 2] = context.returned::<2>(35)?; seed.full(112, v_89); seed.full(120, v_90); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = context.call::<1>(36, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(16, v_91); let [v_93, v_94]: [G; 2] = context.returned::<2>(39)?; seed.full(24, v_93); seed.full(32, v_94); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = context.call::<1>(40, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(16, v_95); let [v_97, v_98]: [G; 2] = context.returned::<2>(43)?; seed.full(24, v_97); seed.full(32, v_98); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = context.returned::<2>(44)?; seed.full(16, v_99); seed.full(24, v_100); Ok(()) }, 11u64 => { let [v_101]: [G; 1] = [G::from_u64(11)]; let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.store(47, &[v_101, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102, v_102])?; seed.full(16, v_103); Ok(()) }, _ => { Err(no_match(95, v_1)) }, } } + +fn write_95(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_15.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); let [v_25, v_26]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 22] = v_29.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 11] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_38.as_canonical_u64(); let [v_39, v_40]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_40.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 22] = v_43.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52]: [G; 9] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 11] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_52.as_canonical_u64(); let [v_53, v_54]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_54.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 22] = v_56.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_59]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_59.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_62]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_62.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_63.as_canonical_u64(); let [v_65, v_66]: [G; 2] = [G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_66.as_canonical_u64(); let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84]: [G; 18] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 14] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_84.as_canonical_u64(); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = [G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 32] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_88.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 32] = (v_67 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_89, v_90]: [G; 2] = [G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 33] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_90.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_91.as_canonical_u64(); let [v_93, v_94]: [G; 2] = [G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_94.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_95.as_canonical_u64(); let [v_97, v_98]: [G; 2] = [G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_98.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_100.as_canonical_u64(); row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); Ok(()) }, 11u64 => { let [v_103]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_103.as_canonical_u64(); row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(95, v_1)) }, } } + +static SCHEMA_95: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 128, 140, 141, 8, 142, 143, 144, 145, 146, 147, 132, 16, 24, 32, 148, 40, 48, 149, 56, 64, 72, 80, 88, 136, 96, 150, 151, 152, 153, 154, 155, 104, 112, 120], bytes: 160 }; + +fn pack_100(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 6, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[10] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = context.call::<2>(3, 95, &[v_0])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = context.call::<8>(4, 17, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[13] = v_14.as_canonical_u64(); seed[14] = v_15.as_canonical_u64(); seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = context.call::<2>(5, 100, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(7, &[v_24, v_12, v_22])?; seed[23] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(100, v_9)) }, } } + +fn pack_100_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 6, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(168, v_9); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10])?; seed.full(72, v_11); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = context.call::<2>(3, 95, &[v_0])?; seed.full(72, v_12); seed.u32(156, v_13); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = context.call::<8>(4, 17, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.full(80, v_14); seed.full(88, v_15); seed.full(96, v_16); seed.full(104, v_17); seed.full(112, v_18); seed.full(120, v_19); seed.full(128, v_20); seed.full(136, v_21); let [v_22, v_23]: [G; 2] = context.call::<2>(5, 100, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed.u32(160, v_22); seed.full(144, v_23); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(7, &[v_24, v_12, v_22])?; seed.u32(164, v_25); Ok(()) }, _ => { Err(no_match(100, v_9)) }, } } + +fn write_100(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let [v_9]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13]: [G; 2] = [G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 8] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = [G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_23.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 14] = v_25.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(100, v_9)) }, } } + +static SCHEMA_100: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 152, 8, 16, 24, 32, 40, 48, 56, 64, 168, 72, 156, 80, 88, 96, 104, 112, 120, 128, 136, 160, 144, 164], bytes: 176 }; + +fn pack_122(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_0.as_canonical_u64() { 0u64 => { let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 13] = context.call::<13>(0, 107, &[v_1])?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60]: [G; 45] = context.call::<45>(2, 110, &[v_1])?; seed[3] = v_16.as_canonical_u64(); seed[4] = v_17.as_canonical_u64(); seed[5] = v_18.as_canonical_u64(); seed[6] = v_19.as_canonical_u64(); seed[7] = v_20.as_canonical_u64(); seed[8] = v_21.as_canonical_u64(); seed[9] = v_22.as_canonical_u64(); seed[10] = v_23.as_canonical_u64(); seed[11] = v_24.as_canonical_u64(); seed[12] = v_25.as_canonical_u64(); seed[13] = v_26.as_canonical_u64(); seed[14] = v_27.as_canonical_u64(); seed[15] = v_28.as_canonical_u64(); seed[16] = v_29.as_canonical_u64(); seed[17] = v_30.as_canonical_u64(); seed[18] = v_31.as_canonical_u64(); seed[19] = v_32.as_canonical_u64(); seed[20] = v_33.as_canonical_u64(); seed[21] = v_34.as_canonical_u64(); seed[22] = v_35.as_canonical_u64(); seed[23] = v_36.as_canonical_u64(); seed[24] = v_37.as_canonical_u64(); seed[25] = v_38.as_canonical_u64(); seed[26] = v_39.as_canonical_u64(); seed[27] = v_40.as_canonical_u64(); seed[28] = v_41.as_canonical_u64(); seed[29] = v_42.as_canonical_u64(); seed[30] = v_43.as_canonical_u64(); seed[31] = v_44.as_canonical_u64(); seed[32] = v_45.as_canonical_u64(); seed[33] = v_46.as_canonical_u64(); seed[34] = v_47.as_canonical_u64(); seed[35] = v_48.as_canonical_u64(); seed[36] = v_49.as_canonical_u64(); seed[37] = v_50.as_canonical_u64(); seed[38] = v_51.as_canonical_u64(); seed[39] = v_52.as_canonical_u64(); seed[40] = v_53.as_canonical_u64(); seed[41] = v_54.as_canonical_u64(); seed[42] = v_55.as_canonical_u64(); seed[43] = v_56.as_canonical_u64(); seed[44] = v_57.as_canonical_u64(); seed[45] = v_58.as_canonical_u64(); seed[46] = v_59.as_canonical_u64(); seed[47] = v_60.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 11] = context.call::<11>(4, 112, &[v_1])?; seed[3] = v_62.as_canonical_u64(); seed[4] = v_63.as_canonical_u64(); seed[5] = v_64.as_canonical_u64(); seed[6] = v_65.as_canonical_u64(); seed[7] = v_66.as_canonical_u64(); seed[8] = v_67.as_canonical_u64(); seed[9] = v_68.as_canonical_u64(); seed[10] = v_69.as_canonical_u64(); seed[11] = v_70.as_canonical_u64(); seed[12] = v_71.as_canonical_u64(); seed[13] = v_72.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 11] = context.call::<11>(7, 114, &[v_1])?; seed[3] = v_75.as_canonical_u64(); seed[4] = v_76.as_canonical_u64(); seed[5] = v_77.as_canonical_u64(); seed[6] = v_78.as_canonical_u64(); seed[7] = v_79.as_canonical_u64(); seed[8] = v_80.as_canonical_u64(); seed[9] = v_81.as_canonical_u64(); seed[10] = v_82.as_canonical_u64(); seed[11] = v_83.as_canonical_u64(); seed[12] = v_84.as_canonical_u64(); seed[13] = v_85.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105]: [G; 18] = context.call::<18>(10, 119, &[v_1])?; seed[3] = v_88.as_canonical_u64(); seed[4] = v_89.as_canonical_u64(); seed[5] = v_90.as_canonical_u64(); seed[6] = v_91.as_canonical_u64(); seed[7] = v_92.as_canonical_u64(); seed[8] = v_93.as_canonical_u64(); seed[9] = v_94.as_canonical_u64(); seed[10] = v_95.as_canonical_u64(); seed[11] = v_96.as_canonical_u64(); seed[12] = v_97.as_canonical_u64(); seed[13] = v_98.as_canonical_u64(); seed[14] = v_99.as_canonical_u64(); seed[15] = v_100.as_canonical_u64(); seed[16] = v_101.as_canonical_u64(); seed[17] = v_102.as_canonical_u64(); seed[18] = v_103.as_canonical_u64(); seed[19] = v_104.as_canonical_u64(); seed[20] = v_105.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117]: [G; 10] = context.call::<10>(13, 118, &[v_1])?; seed[3] = v_108.as_canonical_u64(); seed[4] = v_109.as_canonical_u64(); seed[5] = v_110.as_canonical_u64(); seed[6] = v_111.as_canonical_u64(); seed[7] = v_112.as_canonical_u64(); seed[8] = v_113.as_canonical_u64(); seed[9] = v_114.as_canonical_u64(); seed[10] = v_115.as_canonical_u64(); seed[11] = v_116.as_canonical_u64(); seed[12] = v_117.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 10] = context.call::<10>(16, 118, &[v_1])?; seed[3] = v_120.as_canonical_u64(); seed[4] = v_121.as_canonical_u64(); seed[5] = v_122.as_canonical_u64(); seed[6] = v_123.as_canonical_u64(); seed[7] = v_124.as_canonical_u64(); seed[8] = v_125.as_canonical_u64(); seed[9] = v_126.as_canonical_u64(); seed[10] = v_127.as_canonical_u64(); seed[11] = v_128.as_canonical_u64(); seed[12] = v_129.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(19, 118, &[v_1])?; seed[3] = v_132.as_canonical_u64(); seed[4] = v_133.as_canonical_u64(); seed[5] = v_134.as_canonical_u64(); seed[6] = v_135.as_canonical_u64(); seed[7] = v_136.as_canonical_u64(); seed[8] = v_137.as_canonical_u64(); seed[9] = v_138.as_canonical_u64(); seed[10] = v_139.as_canonical_u64(); seed[11] = v_140.as_canonical_u64(); seed[12] = v_141.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(122, v_0)) }, } } + +fn pack_122_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_0.as_canonical_u64() { 0u64 => { let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 13] = context.call::<13>(0, 107, &[v_1])?; seed.full(8, v_2); seed.full(16, v_3); seed.full(24, v_4); seed.full(32, v_5); seed.u8(165, v_6); seed.u8(166, v_7); seed.u8(167, v_8); seed.u8(168, v_9); seed.full(40, v_10); seed.full(48, v_11); seed.full(56, v_12); seed.full(64, v_13); seed.full(72, v_14); Ok(()) }, 1u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60]: [G; 45] = context.call::<45>(2, 110, &[v_1])?; seed.full(8, v_16); seed.full(16, v_17); seed.full(24, v_18); seed.full(32, v_19); seed.u8(165, v_20); seed.u8(166, v_21); seed.u8(167, v_22); seed.u8(168, v_23); seed.full(40, v_24); seed.full(48, v_25); seed.full(56, v_26); seed.full(64, v_27); seed.full(72, v_28); seed.u8(169, v_29); seed.u8(170, v_30); seed.u8(171, v_31); seed.u32(156, v_32); seed.full(80, v_33); seed.full(88, v_34); seed.full(96, v_35); seed.u8(172, v_36); seed.u8(173, v_37); seed.u8(174, v_38); seed.u8(175, v_39); seed.u8(176, v_40); seed.u8(177, v_41); seed.full(104, v_42); seed.full(112, v_43); seed.u8(178, v_44); seed.u8(179, v_45); seed.u8(180, v_46); seed.u8(181, v_47); seed.u8(182, v_48); seed.u8(183, v_49); seed.full(120, v_50); seed.full(128, v_51); seed.u8(184, v_52); seed.u8(185, v_53); seed.u8(186, v_54); seed.u8(187, v_55); seed.u8(188, v_56); seed.u8(189, v_57); seed.full(136, v_58); seed.u32(160, v_59); seed.full(144, v_60); Ok(()) }, 2u64 => { let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 11] = context.call::<11>(4, 112, &[v_1])?; seed.full(8, v_62); seed.full(16, v_63); seed.full(24, v_64); seed.full(32, v_65); seed.u8(165, v_66); seed.u8(166, v_67); seed.u8(167, v_68); seed.u8(168, v_69); seed.full(40, v_70); seed.full(48, v_71); seed.full(56, v_72); Ok(()) }, 3u64 => { let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 11] = context.call::<11>(7, 114, &[v_1])?; seed.full(8, v_75); seed.full(16, v_76); seed.full(24, v_77); seed.full(32, v_78); seed.u8(165, v_79); seed.u8(166, v_80); seed.u8(167, v_81); seed.u8(168, v_82); seed.full(40, v_83); seed.full(48, v_84); seed.full(56, v_85); Ok(()) }, 4u64 => { let [v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105]: [G; 18] = context.call::<18>(10, 119, &[v_1])?; seed.full(8, v_88); seed.full(16, v_89); seed.full(24, v_90); seed.full(32, v_91); seed.u8(165, v_92); seed.u8(166, v_93); seed.u8(167, v_94); seed.u8(168, v_95); seed.full(40, v_96); seed.full(48, v_97); seed.full(56, v_98); seed.full(64, v_99); seed.full(72, v_100); seed.u8(169, v_101); seed.u8(170, v_102); seed.u8(171, v_103); seed.u32(156, v_104); seed.full(80, v_105); Ok(()) }, 5u64 => { let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117]: [G; 10] = context.call::<10>(13, 118, &[v_1])?; seed.full(8, v_108); seed.full(16, v_109); seed.full(24, v_110); seed.full(32, v_111); seed.u8(165, v_112); seed.u8(166, v_113); seed.u8(167, v_114); seed.u8(168, v_115); seed.full(40, v_116); seed.full(48, v_117); Ok(()) }, 6u64 => { let [v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 10] = context.call::<10>(16, 118, &[v_1])?; seed.full(8, v_120); seed.full(16, v_121); seed.full(24, v_122); seed.full(32, v_123); seed.u8(165, v_124); seed.u8(166, v_125); seed.u8(167, v_126); seed.u8(168, v_127); seed.full(40, v_128); seed.full(48, v_129); Ok(()) }, 7u64 => { let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(19, 118, &[v_1])?; seed.full(8, v_132); seed.full(16, v_133); seed.full(24, v_134); seed.full(32, v_135); seed.u8(165, v_136); seed.u8(166, v_137); seed.u8(167, v_138); seed.u8(168, v_139); seed.full(40, v_140); seed.full(48, v_141); Ok(()) }, _ => { Err(no_match(122, v_0)) }, } } + +fn write_122(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_0.as_canonical_u64() { 0u64 => { let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 13] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60]: [G; 45] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_60.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 11] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_72.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 11] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_85.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105]: [G; 18] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 1] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_105.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_117.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_129.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_141.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(122, v_0)) }, } } + +static SCHEMA_122: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 164, 152, 8, 16, 24, 32, 165, 166, 167, 168, 40, 48, 56, 64, 72, 169, 170, 171, 156, 80, 88, 96, 172, 173, 174, 175, 176, 177, 104, 112, 178, 179, 180, 181, 182, 183, 120, 128, 184, 185, 186, 187, 188, 189, 136, 160, 144], bytes: 192 }; + +fn pack_125(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = context.call::<2>(1, 125, &[v_2])?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.call::<1>(2, 783, &[v_6, v_3])?; seed[8] = v_7.as_canonical_u64(); Ok(()) }, _ => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = context.store(4, &[v_8, v_8, v_8])?; seed[6] = v_9.as_canonical_u64(); Ok(()) }, } } + +fn pack_125_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(48, v_1); seed.u32(36, v_2); seed.full(8, v_3); seed.full(16, v_4); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = context.call::<2>(1, 125, &[v_2])?; seed.full(24, v_5); seed.u32(40, v_6); let [v_7]: [G; 1] = context.call::<1>(2, 783, &[v_6, v_3])?; seed.u32(44, v_7); Ok(()) }, _ => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = context.store(4, &[v_8, v_8, v_8])?; seed.full(24, v_9); Ok(()) }, } } + +fn write_125(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4]: [G; 4] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 3u64 => { let [v_5, v_6]: [G; 2] = [G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 5] = (v_1 - G::from_u64(3)).inverse().as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_125: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 32, 48, 36, 8, 16, 24, 40, 44], bytes: 56 }; + +fn pack_127(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = context.load::<10>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(1)?; seed[14] = v_13.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = context.load::<10>(2, v_1)?; seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); seed[20] = v_20.as_canonical_u64(); seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); seed[23] = v_23.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_24]: [G; 1] = context.returned::<1>(3)?; seed[24] = v_24.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = context.call::<9>(4, 15, &[v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22])?; seed[24] = v_25.as_canonical_u64(); seed[25] = v_26.as_canonical_u64(); seed[26] = v_27.as_canonical_u64(); seed[27] = v_28.as_canonical_u64(); seed[28] = v_29.as_canonical_u64(); seed[29] = v_30.as_canonical_u64(); seed[30] = v_31.as_canonical_u64(); seed[31] = v_32.as_canonical_u64(); seed[32] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = context.call::<9>(6, 15, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_2, v_34, v_34, v_34, v_34, v_34, v_34, v_34])?; seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [v_33 + v_43]; let [v_45]: [G; 1] = context.call::<1>(8, 127, &[v_12, v_23, v_44])?; seed[42] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = context.store(9, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_45])?; seed[43] = v_46.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(127, v_14)) }, } }, _ => { Err(no_match(127, v_3)) }, } } + +fn pack_127_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(45, v_3); seed.u8(46, v_4); seed.u8(47, v_5); seed.u8(48, v_6); seed.u8(49, v_7); seed.u8(50, v_8); seed.u8(51, v_9); seed.u8(52, v_10); seed.u8(53, v_11); seed.u32(24, v_12); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(1)?; seed.u32(28, v_13); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = context.load::<10>(2, v_1)?; seed.u32(28, v_14); seed.u8(54, v_15); seed.u8(55, v_16); seed.u8(56, v_17); seed.u8(57, v_18); seed.u8(58, v_19); seed.u8(59, v_20); seed.u8(60, v_21); seed.u8(61, v_22); seed.u32(32, v_23); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_24]: [G; 1] = context.returned::<1>(3)?; seed.u32(36, v_24); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = context.call::<9>(4, 15, &[v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22])?; seed.u32(36, v_25); seed.u8(62, v_26); seed.u8(63, v_27); seed.u8(64, v_28); seed.u8(65, v_29); seed.u8(66, v_30); seed.u8(67, v_31); seed.u8(68, v_32); seed.u8(69, v_33); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = context.call::<9>(6, 15, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_2, v_34, v_34, v_34, v_34, v_34, v_34, v_34])?; seed.u8(70, v_35); seed.u8(71, v_36); seed.u8(72, v_37); seed.u8(73, v_38); seed.u8(74, v_39); seed.u8(75, v_40); seed.u8(76, v_41); seed.u8(77, v_42); seed.u8(78, v_43); let [v_44]: [G; 1] = [v_33 + v_43]; let [v_45]: [G; 1] = context.call::<1>(8, 127, &[v_12, v_23, v_44])?; seed.full(8, v_45); let [v_46]: [G; 1] = context.store(9, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_45])?; seed.u32(40, v_46); Ok(()) }, _ => { Err(no_match(127, v_14)) }, } }, _ => { Err(no_match(127, v_3)) }, } } + +fn write_127(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 10] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 11] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 10] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { match v_2.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 21] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 9] = [G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 21] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_33.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 9] = [G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41])]; row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_43.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[42])]; row[offsets.auxiliaries + 39] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = [G::from_u64(seed[43])]; row[offsets.auxiliaries + 40] = v_46.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(127, v_14)) }, } }, _ => { Err(no_match(127, v_3)) }, } } + +static SCHEMA_127: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 16, 20, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 24, 28, 54, 55, 56, 57, 58, 59, 60, 61, 32, 36, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 8, 40], bytes: 80 }; + +fn pack_132(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed[12] = v_12.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = context.call::<2>(8, 132, &[v_10])?; seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(9, 3, &[v_15])?; seed[14] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(11, &[v_17, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14])?; seed[15] = v_18.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(132, v_1)) }, } } + +fn pack_132_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(36, v_1); seed.u8(37, v_2); seed.u8(38, v_3); seed.u8(39, v_4); seed.u8(40, v_5); seed.u8(41, v_6); seed.u8(42, v_7); seed.u8(43, v_8); seed.u8(44, v_9); seed.u32(20, v_10); match v_1.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = context.store(2, &[v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11, v_11])?; seed.u32(24, v_12); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = context.call::<2>(8, 132, &[v_10])?; seed.u32(24, v_14); seed.u32(28, v_15); let [v_16]: [G; 1] = context.call::<1>(9, 3, &[v_15])?; seed.full(8, v_16); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(11, &[v_17, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14])?; seed.u32(32, v_18); Ok(()) }, _ => { Err(no_match(132, v_1)) }, } } + +fn write_132(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 14] = v_18.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(132, v_1)) }, } } + +static SCHEMA_132: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 16, 36, 37, 38, 39, 40, 41, 42, 43, 44, 20, 24, 28, 8, 32], bytes: 48 }; + +fn pack_140(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_5]: [G; 1] = context.returned::<1>(3)?; seed[4] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_140_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed.u32(24, v_3); let [v_5]: [G; 1] = context.returned::<1>(3)?; seed.full(8, v_5); Ok(()) } + +fn write_140(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_140: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 20, 24, 8], bytes: 32 }; + +fn pack_142(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = context.load::<10>(0, v_8)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = context.call::<1>(1, 6, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[28] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(3, &[v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed[29] = v_29.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(6, &[v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31])?; seed[29] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.store(7, &[v_30, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_32])?; seed[30] = v_33.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(142, v_27)) }, } }, 0u64 => { let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 16] = context.call::<16>(8, 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])?; seed[28] = v_34.as_canonical_u64(); seed[29] = v_35.as_canonical_u64(); seed[30] = v_36.as_canonical_u64(); seed[31] = v_37.as_canonical_u64(); seed[32] = v_38.as_canonical_u64(); seed[33] = v_39.as_canonical_u64(); seed[34] = v_40.as_canonical_u64(); seed[35] = v_41.as_canonical_u64(); seed[36] = v_42.as_canonical_u64(); seed[37] = v_43.as_canonical_u64(); seed[38] = v_44.as_canonical_u64(); seed[39] = v_45.as_canonical_u64(); seed[40] = v_46.as_canonical_u64(); seed[41] = v_47.as_canonical_u64(); seed[42] = v_48.as_canonical_u64(); seed[43] = v_49.as_canonical_u64(); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = context.call::<9>(9, 15, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[44] = v_50.as_canonical_u64(); seed[45] = v_51.as_canonical_u64(); seed[46] = v_52.as_canonical_u64(); seed[47] = v_53.as_canonical_u64(); seed[48] = v_54.as_canonical_u64(); seed[49] = v_55.as_canonical_u64(); seed[50] = v_56.as_canonical_u64(); seed[51] = v_57.as_canonical_u64(); seed[52] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = context.call::<1>(11, 142, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed[53] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = context.store(12, &[v_59, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_60])?; seed[54] = v_61.as_canonical_u64(); Ok(()) }, _ => { let [v_62]: [G; 1] = [G::from_u64(0)]; let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = context.call::<8>(14, 16, &[v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed[53] = v_63.as_canonical_u64(); seed[54] = v_64.as_canonical_u64(); seed[55] = v_65.as_canonical_u64(); seed[56] = v_66.as_canonical_u64(); seed[57] = v_67.as_canonical_u64(); seed[58] = v_68.as_canonical_u64(); seed[59] = v_69.as_canonical_u64(); seed[60] = v_70.as_canonical_u64(); let [v_71]: [G; 1] = context.call::<1>(15, 142, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70])?; seed[61] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = context.store(16, &[v_62, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_71])?; seed[62] = v_72.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(142, v_17)) }, } } + +fn pack_142_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = context.load::<10>(0, v_8)?; seed.u8(176, v_17); seed.full(72, v_18); seed.full(80, v_19); seed.full(88, v_20); seed.full(96, v_21); seed.full(104, v_22); seed.full(112, v_23); seed.full(120, v_24); seed.full(128, v_25); seed.u32(140, v_26); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = context.call::<1>(1, 6, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u8(177, v_27); match v_27.as_canonical_u64() { 1u64 => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(3, &[v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28, v_28])?; seed.u32(144, v_29); Ok(()) }, 0u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(6, &[v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31, v_31])?; seed.u32(144, v_32); let [v_33]: [G; 1] = context.store(7, &[v_30, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_32])?; seed.u32(148, v_33); Ok(()) }, _ => { Err(no_match(142, v_27)) }, } }, 0u64 => { let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 16] = context.call::<16>(8, 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])?; seed.u8(177, v_34); seed.u32(144, v_35); seed.u32(148, v_36); seed.u8(178, v_37); seed.u8(179, v_38); seed.u8(180, v_39); seed.u8(181, v_40); seed.u8(182, v_41); seed.u8(183, v_42); seed.u8(184, v_43); seed.u8(185, v_44); seed.u8(186, v_45); seed.u8(187, v_46); seed.u8(188, v_47); seed.u8(189, v_48); seed.u8(190, v_49); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = context.call::<9>(9, 15, &[v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u8(191, v_50); seed.u8(192, v_51); seed.u8(193, v_52); seed.u8(194, v_53); seed.u8(195, v_54); seed.u8(196, v_55); seed.u8(197, v_56); seed.u8(198, v_57); seed.u8(199, v_58); match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = context.call::<1>(11, 142, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed.u32(152, v_60); let [v_61]: [G; 1] = context.store(12, &[v_59, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_60])?; seed.u32(156, v_61); Ok(()) }, _ => { let [v_62]: [G; 1] = [G::from_u64(0)]; let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = context.call::<8>(14, 16, &[v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49])?; seed.u32(152, v_63); seed.u32(156, v_64); seed.u8(200, v_65); seed.u8(201, v_66); seed.u8(202, v_67); seed.u8(203, v_68); seed.u8(204, v_69); seed.u8(205, v_70); let [v_71]: [G; 1] = context.call::<1>(15, 142, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_26, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70])?; seed.u32(160, v_71); let [v_72]: [G; 1] = context.store(16, &[v_62, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_71])?; seed.u32(164, v_72); Ok(()) }, } }, _ => { Err(no_match(142, v_17)) }, } } + +fn write_142(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 10] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_26.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 11] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_29]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_32]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 12] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 13] = v_33.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(142, v_27)) }, } }, 0u64 => { let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 16] = [G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 11] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_49.as_canonical_u64(); let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58]: [G; 9] = [G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 27] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_60]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 36] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 37] = v_61.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 36] = (v_58 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70]: [G; 8] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 37] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_70.as_canonical_u64(); let [v_71]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 45] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = [G::from_u64(seed[62])]; row[offsets.auxiliaries + 46] = v_72.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(142, v_17)) }, } } + +static SCHEMA_142: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 64, 136, 168, 169, 170, 171, 172, 173, 174, 175, 176, 72, 80, 88, 96, 104, 112, 120, 128, 140, 177, 144, 148, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 152, 156, 200, 201, 202, 203, 204, 205, 160, 164], bytes: 208 }; + +fn pack_151(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_151_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn write_151(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_16]: [G; 1] = [Bytes2::or(&v_0, &v_8)]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [Bytes2::or(&v_1, &v_9)]; row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [Bytes2::or(&v_2, &v_10)]; row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [Bytes2::or(&v_3, &v_11)]; row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [Bytes2::or(&v_4, &v_12)]; row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [Bytes2::or(&v_5, &v_13)]; row[offsets.auxiliaries + 6] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [Bytes2::or(&v_6, &v_14)]; row[offsets.auxiliaries + 7] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [Bytes2::or(&v_7, &v_15)]; row[offsets.auxiliaries + 8] = v_23.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_151: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], bytes: 24 }; + +fn pack_152(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_152_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn write_152(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_16]: [G; 1] = [Bytes2::xor(&v_0, &v_8)]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [Bytes2::xor(&v_1, &v_9)]; row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [Bytes2::xor(&v_2, &v_10)]; row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [Bytes2::xor(&v_3, &v_11)]; row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [Bytes2::xor(&v_4, &v_12)]; row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [Bytes2::xor(&v_5, &v_13)]; row[offsets.auxiliaries + 6] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [Bytes2::xor(&v_6, &v_14)]; row[offsets.auxiliaries + 7] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [Bytes2::xor(&v_7, &v_15)]; row[offsets.auxiliaries + 8] = v_23.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_152: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], bytes: 24 }; + +fn pack_154(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 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])?; seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); seed[29] = v_29.as_canonical_u64(); seed[30] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(4, 154, &[v_11, v_21])?; seed[31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed[32] = v_32.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(154, v_12)) }, } }, _ => { Err(no_match(154, v_2)) }, } } + +fn pack_154_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(36, v_2); seed.u8(37, v_3); seed.u8(38, v_4); seed.u8(39, v_5); seed.u8(40, v_6); seed.u8(41, v_7); seed.u8(42, v_8); seed.u8(43, v_9); seed.u8(44, v_10); seed.u32(24, v_11); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; seed.u8(45, v_12); seed.u8(46, v_13); seed.u8(47, v_14); seed.u8(48, v_15); seed.u8(49, v_16); seed.u8(50, v_17); seed.u8(51, v_18); seed.u8(52, v_19); seed.u8(53, v_20); seed.u32(28, v_21); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 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])?; seed.u8(54, v_23); seed.u8(55, v_24); seed.u8(56, v_25); seed.u8(57, v_26); seed.u8(58, v_27); seed.u8(59, v_28); seed.u8(60, v_29); seed.u8(61, v_30); let [v_31]: [G; 1] = context.call::<1>(4, 154, &[v_11, v_21])?; seed.full(8, v_31); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed.u32(32, v_32); Ok(()) }, _ => { Err(no_match(154, v_12)) }, } }, _ => { Err(no_match(154, v_2)) }, } } + +fn write_154(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(154, v_12)) }, } }, _ => { Err(no_match(154, v_2)) }, } } + +static SCHEMA_154: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 16, 20, 36, 37, 38, 39, 40, 41, 42, 43, 44, 24, 45, 46, 47, 48, 49, 50, 51, 52, 53, 28, 54, 55, 56, 57, 58, 59, 60, 61, 8, 32], bytes: 64 }; + +fn pack_155(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 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])?; seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); seed[29] = v_29.as_canonical_u64(); seed[30] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(4, 155, &[v_11, v_21])?; seed[31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed[32] = v_32.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(155, v_12)) }, } }, _ => { Err(no_match(155, v_2)) }, } } + +fn pack_155_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(36, v_2); seed.u8(37, v_3); seed.u8(38, v_4); seed.u8(39, v_5); seed.u8(40, v_6); seed.u8(41, v_7); seed.u8(42, v_8); seed.u8(43, v_9); seed.u8(44, v_10); seed.u32(24, v_11); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; seed.u8(45, v_12); seed.u8(46, v_13); seed.u8(47, v_14); seed.u8(48, v_15); seed.u8(49, v_16); seed.u8(50, v_17); seed.u8(51, v_18); seed.u8(52, v_19); seed.u8(53, v_20); seed.u32(28, v_21); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 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])?; seed.u8(54, v_23); seed.u8(55, v_24); seed.u8(56, v_25); seed.u8(57, v_26); seed.u8(58, v_27); seed.u8(59, v_28); seed.u8(60, v_29); seed.u8(61, v_30); let [v_31]: [G; 1] = context.call::<1>(4, 155, &[v_11, v_21])?; seed.full(8, v_31); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed.u32(32, v_32); Ok(()) }, _ => { Err(no_match(155, v_12)) }, } }, _ => { Err(no_match(155, v_2)) }, } } + +fn write_155(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(155, v_12)) }, } }, _ => { Err(no_match(155, v_2)) }, } } + +static SCHEMA_155: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 16, 20, 36, 37, 38, 39, 40, 41, 42, 43, 44, 24, 45, 46, 47, 48, 49, 50, 51, 52, 53, 28, 54, 55, 56, 57, 58, 59, 60, 61, 8, 32], bytes: 64 }; + +fn pack_230(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 217, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 218, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 219, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 224, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 225, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 226, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 228, &[])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } }, } } + +fn pack_230_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 217, &[])?; seed.u32(12, v_1); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed.u8(40, v_2); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 218, &[])?; seed.u32(16, v_4); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed.u8(41, v_5); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 219, &[])?; seed.u32(20, v_7); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed.u8(42, v_8); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 224, &[])?; seed.u32(24, v_10); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed.u8(43, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 225, &[])?; seed.u32(28, v_13); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed.u8(44, v_14); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 226, &[])?; seed.u32(32, v_16); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed.u8(45, v_17); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 228, &[])?; seed.u32(36, v_19); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed.u8(46, v_20); Ok(()) }, } }, } }, } }, } }, } }, } } + +fn write_230(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_2 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 6] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 15] = (v_14 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 18] = (v_17 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 21] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, } }, } }, } }, } }, } }, } } + +static SCHEMA_230: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 40, 16, 41, 20, 42, 24, 43, 28, 44, 32, 45, 36, 46], bytes: 48 }; + +fn pack_241(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 3u64 => { let [v_6, v_7, v_8, v_9]: [G; 4] = context.load::<4>(1, v_3)?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_6.as_canonical_u64() { 2u64 => { let [v_10]: [G; 1] = context.call::<1>(2, 298, &[v_7])?; seed[11] = v_10.as_canonical_u64(); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 12] = context.load::<12>(3, v_10)?; seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(5, &[v_23, v_23, v_23])?; seed[24] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = context.call::<1>(6, 347, &[v_14, v_24])?; seed[25] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(7, v_25)?; seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); seed[29] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 4u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = context.call::<1>(9, 378, &[v_28, v_4, v_30])?; seed[30] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.returned::<1>(10)?; seed[31] = v_32.as_canonical_u64(); Ok(()) }, _ => { let [v_33]: [G; 1] = [G::from_u64(3)]; let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(13, &[v_33, v_25, v_4, v_34])?; seed[30] = v_35.as_canonical_u64(); let [v_36]: [G; 1] = context.returned::<1>(14)?; seed[31] = v_36.as_canonical_u64(); Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } } + +fn pack_241_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(176, v_2); seed.u32(136, v_3); seed.u32(140, v_4); seed.full(8, v_5); match v_2.as_canonical_u64() { 3u64 => { let [v_6, v_7, v_8, v_9]: [G; 4] = context.load::<4>(1, v_3)?; seed.u8(177, v_6); seed.u32(144, v_7); seed.full(16, v_8); seed.full(24, v_9); match v_6.as_canonical_u64() { 2u64 => { let [v_10]: [G; 1] = context.call::<1>(2, 298, &[v_7])?; seed.u32(148, v_10); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 12] = context.load::<12>(3, v_10)?; seed.u8(178, v_11); seed.full(32, v_12); seed.u32(152, v_13); seed.u32(156, v_14); seed.full(40, v_15); seed.full(48, v_16); seed.full(56, v_17); seed.full(64, v_18); seed.full(72, v_19); seed.full(80, v_20); seed.full(88, v_21); seed.full(96, v_22); match v_11.as_canonical_u64() { 1u64 => { let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(5, &[v_23, v_23, v_23])?; seed.u32(160, v_24); let [v_25]: [G; 1] = context.call::<1>(6, 347, &[v_14, v_24])?; seed.u32(164, v_25); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(7, v_25)?; seed.u8(179, v_26); seed.full(104, v_27); seed.u32(168, v_28); seed.full(112, v_29); match v_26.as_canonical_u64() { 4u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = context.call::<1>(9, 378, &[v_28, v_4, v_30])?; seed.u32(172, v_31); let [v_32]: [G; 1] = context.returned::<1>(10)?; seed.full(120, v_32); Ok(()) }, _ => { let [v_33]: [G; 1] = [G::from_u64(3)]; let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(13, &[v_33, v_25, v_4, v_34])?; seed.u32(172, v_35); let [v_36]: [G; 1] = context.returned::<1>(14)?; seed.full(120, v_36); Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } } + +fn write_241(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5]: [G; 4] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 3u64 => { let [v_6, v_7, v_8, v_9]: [G; 4] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); match v_6.as_canonical_u64() { 2u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 12] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[25])]; row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29])]; row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 4u64 => { let [v_31]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 28] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 29] = v_32.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 28] = (v_26 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 29] = v_35.as_canonical_u64(); let [v_36]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 30] = v_36.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 22] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_6 - G::from_u64(2)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 5] = (v_2 - G::from_u64(3)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_241: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 128, 132, 176, 136, 140, 8, 177, 144, 16, 24, 148, 178, 32, 152, 156, 40, 48, 56, 64, 72, 80, 88, 96, 160, 164, 179, 104, 168, 112, 172, 120], bytes: 184 }; + +fn pack_266(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(3)]; let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_5, v_0, v_3, v_6])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.returned::<1>(4)?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(266, v_2)) }, } } + +fn pack_266_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(44, v_2); seed.full(16, v_3); seed.u32(36, v_4); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(3)]; let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_5, v_0, v_3, v_6])?; seed.u32(40, v_7); let [v_8]: [G; 1] = context.returned::<1>(4)?; seed.full(24, v_8); Ok(()) }, _ => { Err(no_match(266, v_2)) }, } } + +fn write_266(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(266, v_2)) }, } } + +static SCHEMA_266: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 8, 32, 44, 16, 36, 40, 24], bytes: 48 }; + +fn pack_297(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; match v_0.as_canonical_u64() { _ => { let [v_14]: [G; 1] = context.call::<1>(0, 296, &[v_0, v_1])?; seed[15] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(2, &[v_15, v_15, v_15])?; seed[16] = v_16.as_canonical_u64(); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(3)?; seed[16] = v_17.as_canonical_u64(); Ok(()) }, } }, } } + +fn pack_297_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; match v_0.as_canonical_u64() { _ => { let [v_14]: [G; 1] = context.call::<1>(0, 296, &[v_0, v_1])?; seed.u8(106, v_14); match v_14.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(2, &[v_15, v_15, v_15])?; seed.u32(100, v_16); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(3)?; seed.u32(100, v_17); Ok(()) }, } }, } } + +fn write_297(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); match v_0.as_canonical_u64() { _ => { let [v_14]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 1] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 2] = (v_14 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, } } + +static SCHEMA_297: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 104, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 105, 106, 100], bytes: 112 }; + +fn pack_300(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); match v_2.as_canonical_u64() { _ => { match v_2.as_canonical_u64() { 8u64 => { let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94]: [G; 45] = context.call::<45>(1, 303, &[v_3, v_1])?; seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); seed[95] = v_94.as_canonical_u64(); match v_50.as_canonical_u64() { 1u64 => { let [v_95]: [G; 1] = context.call::<1>(2, 306, &[v_3, v_0])?; seed[96] = v_95.as_canonical_u64(); let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107]: [G; 12] = context.call::<12>(3, 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])?; seed[97] = v_96.as_canonical_u64(); seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); let [v_108]: [G; 1] = context.store(4, &[v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107])?; seed[109] = v_108.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(300, v_50)) }, } }, _ => { Err(no_match(300, v_2)) }, } }, } } + +fn pack_300_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed.u8(337, v_2); seed.u32(288, v_3); seed.full(16, v_4); seed.full(24, v_5); seed.full(32, v_6); seed.u8(338, v_7); seed.u8(339, v_8); seed.u8(340, v_9); seed.u8(341, v_10); seed.full(40, v_11); seed.full(48, v_12); seed.full(56, v_13); seed.full(64, v_14); seed.u8(342, v_15); seed.u8(343, v_16); seed.u8(344, v_17); seed.u8(345, v_18); seed.u32(292, v_19); seed.u8(346, v_20); seed.full(72, v_21); seed.full(80, v_22); seed.u8(347, v_23); seed.u8(348, v_24); seed.u8(349, v_25); seed.u8(350, v_26); seed.u8(351, v_27); seed.u8(352, v_28); seed.full(88, v_29); seed.full(96, v_30); seed.u8(353, v_31); seed.u8(354, v_32); seed.u8(355, v_33); seed.u8(356, v_34); seed.u8(357, v_35); seed.u8(358, v_36); seed.full(104, v_37); seed.full(112, v_38); seed.u8(359, v_39); seed.u8(360, v_40); seed.u8(361, v_41); seed.u8(362, v_42); seed.u8(363, v_43); seed.u8(364, v_44); seed.full(120, v_45); seed.u32(296, v_46); seed.u32(300, v_47); seed.u32(304, v_48); seed.u32(308, v_49); match v_2.as_canonical_u64() { _ => { match v_2.as_canonical_u64() { 8u64 => { let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94]: [G; 45] = context.call::<45>(1, 303, &[v_3, v_1])?; seed.u8(365, v_50); seed.u8(366, v_51); seed.full(128, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.u8(367, v_55); seed.u8(368, v_56); seed.u8(369, v_57); seed.u8(370, v_58); seed.u8(371, v_59); seed.full(152, v_60); seed.full(160, v_61); seed.full(168, v_62); seed.u8(372, v_63); seed.u8(373, v_64); seed.u8(374, v_65); seed.u8(375, v_66); seed.u8(376, v_67); seed.full(176, v_68); seed.full(184, v_69); seed.full(192, v_70); seed.u8(377, v_71); seed.u8(378, v_72); seed.u8(379, v_73); seed.u8(380, v_74); seed.u8(381, v_75); seed.u32(312, v_76); seed.u32(316, v_77); seed.full(200, v_78); seed.u8(382, v_79); seed.u8(383, v_80); seed.u8(384, v_81); seed.u8(385, v_82); seed.u8(386, v_83); seed.u8(387, v_84); seed.full(208, v_85); seed.full(216, v_86); seed.u8(388, v_87); seed.u8(389, v_88); seed.u8(390, v_89); seed.u8(391, v_90); seed.u8(392, v_91); seed.u8(393, v_92); seed.full(224, v_93); seed.u32(320, v_94); match v_50.as_canonical_u64() { 1u64 => { let [v_95]: [G; 1] = context.call::<1>(2, 306, &[v_3, v_0])?; seed.u32(324, v_95); let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107]: [G; 12] = context.call::<12>(3, 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])?; seed.u8(394, v_96); seed.full(232, v_97); seed.u32(328, v_98); seed.full(240, v_99); seed.full(248, v_100); seed.full(256, v_101); seed.full(264, v_102); seed.full(272, v_103); seed.full(280, v_104); seed.u8(395, v_105); seed.u8(396, v_106); seed.u8(397, v_107); let [v_108]: [G; 1] = context.store(4, &[v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107])?; seed.u32(332, v_108); Ok(()) }, _ => { Err(no_match(300, v_50)) }, } }, _ => { Err(no_match(300, v_2)) }, } }, } } + +fn write_300(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 48] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); match v_2.as_canonical_u64() { _ => { match v_2.as_canonical_u64() { 8u64 => { let [v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94]: [G; 45] = [G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95])]; row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_94.as_canonical_u64(); match v_50.as_canonical_u64() { 1u64 => { let [v_95]: [G; 1] = [G::from_u64(seed[96])]; row[offsets.auxiliaries + 94] = v_95.as_canonical_u64(); let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107]: [G; 12] = [G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108])]; row[offsets.auxiliaries + 95] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_107.as_canonical_u64(); let [v_108]: [G; 1] = [G::from_u64(seed[109])]; row[offsets.auxiliaries + 107] = v_108.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(300, v_50)) }, } }, _ => { Err(no_match(300, v_2)) }, } }, } } + +static SCHEMA_300: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 336, 8, 337, 288, 16, 24, 32, 338, 339, 340, 341, 40, 48, 56, 64, 342, 343, 344, 345, 292, 346, 72, 80, 347, 348, 349, 350, 351, 352, 88, 96, 353, 354, 355, 356, 357, 358, 104, 112, 359, 360, 361, 362, 363, 364, 120, 296, 300, 304, 308, 365, 366, 128, 136, 144, 367, 368, 369, 370, 371, 152, 160, 168, 372, 373, 374, 375, 376, 176, 184, 192, 377, 378, 379, 380, 381, 312, 316, 200, 382, 383, 384, 385, 386, 387, 208, 216, 388, 389, 390, 391, 392, 393, 224, 320, 324, 394, 232, 328, 240, 248, 256, 264, 272, 280, 395, 396, 397, 332], bytes: 400 }; + +fn pack_301(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95]: [G; 45] = context.call::<45>(1, 303, &[v_4, v_1])?; seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); match v_51.as_canonical_u64() { 1u64 => { match v_52.as_canonical_u64() { _ => { let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 34] = context.call::<34>(2, 288, &[v_78, v_2])?; seed[97] = v_96.as_canonical_u64(); seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = context.call::<1>(3, 306, &[v_4, v_0])?; seed[131] = v_130.as_canonical_u64(); let [v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142]: [G; 12] = context.call::<12>(4, 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])?; seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); seed[143] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = context.store(5, &[v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142])?; seed[144] = v_143.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(301, v_51)) }, } }, _ => { Err(no_match(301, v_3)) }, } }, } } + +fn pack_301_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed.u8(425, v_3); seed.u32(376, v_4); seed.full(24, v_5); seed.full(32, v_6); seed.full(40, v_7); seed.u8(426, v_8); seed.u8(427, v_9); seed.u8(428, v_10); seed.u8(429, v_11); seed.full(48, v_12); seed.full(56, v_13); seed.full(64, v_14); seed.full(72, v_15); seed.u8(430, v_16); seed.u8(431, v_17); seed.u8(432, v_18); seed.u8(433, v_19); seed.u32(380, v_20); seed.u8(434, v_21); seed.full(80, v_22); seed.full(88, v_23); seed.u8(435, v_24); seed.u8(436, v_25); seed.u8(437, v_26); seed.u8(438, v_27); seed.u8(439, v_28); seed.u8(440, v_29); seed.full(96, v_30); seed.full(104, v_31); seed.u8(441, v_32); seed.u8(442, v_33); seed.u8(443, v_34); seed.u8(444, v_35); seed.u8(445, v_36); seed.u8(446, v_37); seed.full(112, v_38); seed.full(120, v_39); seed.u8(447, v_40); seed.u8(448, v_41); seed.u8(449, v_42); seed.u8(450, v_43); seed.u8(451, v_44); seed.u8(452, v_45); seed.full(128, v_46); seed.u32(384, v_47); seed.u32(388, v_48); seed.u32(392, v_49); seed.u32(396, v_50); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95]: [G; 45] = context.call::<45>(1, 303, &[v_4, v_1])?; seed.u8(453, v_51); seed.u8(454, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.full(152, v_55); seed.u8(455, v_56); seed.u8(456, v_57); seed.u8(457, v_58); seed.u8(458, v_59); seed.u8(459, v_60); seed.full(160, v_61); seed.full(168, v_62); seed.full(176, v_63); seed.u8(460, v_64); seed.u8(461, v_65); seed.u8(462, v_66); seed.u8(463, v_67); seed.u8(464, v_68); seed.full(184, v_69); seed.full(192, v_70); seed.full(200, v_71); seed.u8(465, v_72); seed.u8(466, v_73); seed.u8(467, v_74); seed.u8(468, v_75); seed.u8(469, v_76); seed.full(208, v_77); seed.u32(400, v_78); seed.full(216, v_79); seed.u8(470, v_80); seed.u8(471, v_81); seed.u8(472, v_82); seed.u8(473, v_83); seed.u8(474, v_84); seed.u8(475, v_85); seed.full(224, v_86); seed.full(232, v_87); seed.u8(476, v_88); seed.u8(477, v_89); seed.u8(478, v_90); seed.u8(479, v_91); seed.u8(480, v_92); seed.u8(481, v_93); seed.full(240, v_94); seed.u32(404, v_95); match v_51.as_canonical_u64() { 1u64 => { match v_52.as_canonical_u64() { _ => { let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 34] = context.call::<34>(2, 288, &[v_78, v_2])?; seed.full(248, v_96); seed.full(256, v_97); seed.full(264, v_98); seed.u8(482, v_99); seed.u8(483, v_100); seed.u8(484, v_101); seed.u8(485, v_102); seed.u8(486, v_103); seed.u8(487, v_104); seed.full(272, v_105); seed.full(280, v_106); seed.u8(488, v_107); seed.u8(489, v_108); seed.u8(490, v_109); seed.u8(491, v_110); seed.u8(492, v_111); seed.u8(493, v_112); seed.full(288, v_113); seed.full(296, v_114); seed.u8(494, v_115); seed.u8(495, v_116); seed.u8(496, v_117); seed.u8(497, v_118); seed.u8(498, v_119); seed.u8(499, v_120); seed.full(304, v_121); seed.full(312, v_122); seed.u8(500, v_123); seed.u8(501, v_124); seed.u8(502, v_125); seed.u8(503, v_126); seed.u8(504, v_127); seed.u8(505, v_128); seed.u32(408, v_129); let [v_130]: [G; 1] = context.call::<1>(3, 306, &[v_4, v_0])?; seed.u32(412, v_130); let [v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142]: [G; 12] = context.call::<12>(4, 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])?; seed.u8(506, v_131); seed.full(320, v_132); seed.u32(416, v_133); seed.full(328, v_134); seed.full(336, v_135); seed.full(344, v_136); seed.full(352, v_137); seed.full(360, v_138); seed.full(368, v_139); seed.u8(507, v_140); seed.u8(508, v_141); seed.u8(509, v_142); let [v_143]: [G; 1] = context.store(5, &[v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142])?; seed.u32(420, v_143); Ok(()) }, } }, _ => { Err(no_match(301, v_51)) }, } }, _ => { Err(no_match(301, v_3)) }, } }, } } + +fn write_301(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 48] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95]: [G; 45] = [G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96])]; row[offsets.auxiliaries + 49] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_95.as_canonical_u64(); match v_51.as_canonical_u64() { 1u64 => { match v_52.as_canonical_u64() { _ => { let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 34] = [G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130])]; row[offsets.auxiliaries + 94] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [G::from_u64(seed[131])]; row[offsets.auxiliaries + 128] = v_130.as_canonical_u64(); let [v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142]: [G; 12] = [G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143])]; row[offsets.auxiliaries + 129] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [G::from_u64(seed[144])]; row[offsets.auxiliaries + 141] = v_143.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(301, v_51)) }, } }, _ => { Err(no_match(301, v_3)) }, } }, } } + +static SCHEMA_301: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 424, 8, 16, 425, 376, 24, 32, 40, 426, 427, 428, 429, 48, 56, 64, 72, 430, 431, 432, 433, 380, 434, 80, 88, 435, 436, 437, 438, 439, 440, 96, 104, 441, 442, 443, 444, 445, 446, 112, 120, 447, 448, 449, 450, 451, 452, 128, 384, 388, 392, 396, 453, 454, 136, 144, 152, 455, 456, 457, 458, 459, 160, 168, 176, 460, 461, 462, 463, 464, 184, 192, 200, 465, 466, 467, 468, 469, 208, 400, 216, 470, 471, 472, 473, 474, 475, 224, 232, 476, 477, 478, 479, 480, 481, 240, 404, 248, 256, 264, 482, 483, 484, 485, 486, 487, 272, 280, 488, 489, 490, 491, 492, 493, 288, 296, 494, 495, 496, 497, 498, 499, 304, 312, 500, 501, 502, 503, 504, 505, 408, 412, 506, 320, 416, 328, 336, 344, 352, 360, 368, 507, 508, 509, 420], bytes: 512 }; + +fn pack_303(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 47] = context.load::<47>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95]: [G; 45] = context.returned::<45>(3)?; seed[50] = v_51.as_canonical_u64(); seed[51] = v_52.as_canonical_u64(); seed[52] = v_53.as_canonical_u64(); seed[53] = v_54.as_canonical_u64(); seed[54] = v_55.as_canonical_u64(); seed[55] = v_56.as_canonical_u64(); seed[56] = v_57.as_canonical_u64(); seed[57] = v_58.as_canonical_u64(); seed[58] = v_59.as_canonical_u64(); seed[59] = v_60.as_canonical_u64(); seed[60] = v_61.as_canonical_u64(); seed[61] = v_62.as_canonical_u64(); seed[62] = v_63.as_canonical_u64(); seed[63] = v_64.as_canonical_u64(); seed[64] = v_65.as_canonical_u64(); seed[65] = v_66.as_canonical_u64(); seed[66] = v_67.as_canonical_u64(); seed[67] = v_68.as_canonical_u64(); seed[68] = v_69.as_canonical_u64(); seed[69] = v_70.as_canonical_u64(); seed[70] = v_71.as_canonical_u64(); seed[71] = v_72.as_canonical_u64(); seed[72] = v_73.as_canonical_u64(); seed[73] = v_74.as_canonical_u64(); seed[74] = v_75.as_canonical_u64(); seed[75] = v_76.as_canonical_u64(); seed[76] = v_77.as_canonical_u64(); seed[77] = v_78.as_canonical_u64(); seed[78] = v_79.as_canonical_u64(); seed[79] = v_80.as_canonical_u64(); seed[80] = v_81.as_canonical_u64(); seed[81] = v_82.as_canonical_u64(); seed[82] = v_83.as_canonical_u64(); seed[83] = v_84.as_canonical_u64(); seed[84] = v_85.as_canonical_u64(); seed[85] = v_86.as_canonical_u64(); seed[86] = v_87.as_canonical_u64(); seed[87] = v_88.as_canonical_u64(); seed[88] = v_89.as_canonical_u64(); seed[89] = v_90.as_canonical_u64(); seed[90] = v_91.as_canonical_u64(); seed[91] = v_92.as_canonical_u64(); seed[92] = v_93.as_canonical_u64(); seed[93] = v_94.as_canonical_u64(); seed[94] = v_95.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(303, v_2)) }, } } + +fn pack_303_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 47] = context.load::<47>(0, v_0)?; seed.u8(272, v_2); seed.u8(273, v_3); seed.u8(274, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(275, v_8); seed.u8(276, v_9); seed.u8(277, v_10); seed.u8(278, v_11); seed.u8(279, v_12); seed.full(40, v_13); seed.full(48, v_14); seed.full(56, v_15); seed.u8(280, v_16); seed.u8(281, v_17); seed.u8(282, v_18); seed.u8(283, v_19); seed.u8(284, v_20); seed.full(64, v_21); seed.full(72, v_22); seed.full(80, v_23); seed.u8(285, v_24); seed.u8(286, v_25); seed.u8(287, v_26); seed.u8(288, v_27); seed.u8(289, v_28); seed.full(88, v_29); seed.full(96, v_30); seed.full(104, v_31); seed.u8(290, v_32); seed.u8(291, v_33); seed.u8(292, v_34); seed.u8(293, v_35); seed.u8(294, v_36); seed.u8(295, v_37); seed.full(112, v_38); seed.full(120, v_39); seed.u8(296, v_40); seed.u8(297, v_41); seed.u8(298, v_42); seed.u8(299, v_43); seed.u8(300, v_44); seed.u8(301, v_45); seed.full(128, v_46); seed.u32(260, v_47); seed.u32(264, v_48); match v_2.as_canonical_u64() { 0u64 => { match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95]: [G; 45] = context.returned::<45>(3)?; seed.u8(302, v_51); seed.u8(303, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.full(152, v_55); seed.u8(304, v_56); seed.u8(305, v_57); seed.u8(306, v_58); seed.u8(307, v_59); seed.u8(308, v_60); seed.full(160, v_61); seed.full(168, v_62); seed.full(176, v_63); seed.u8(309, v_64); seed.u8(310, v_65); seed.u8(311, v_66); seed.u8(312, v_67); seed.u8(313, v_68); seed.full(184, v_69); seed.full(192, v_70); seed.full(200, v_71); seed.u8(314, v_72); seed.u8(315, v_73); seed.u8(316, v_74); seed.u8(317, v_75); seed.u8(318, v_76); seed.full(208, v_77); seed.full(216, v_78); seed.full(224, v_79); seed.u8(319, v_80); seed.u8(320, v_81); seed.u8(321, v_82); seed.u8(322, v_83); seed.u8(323, v_84); seed.u8(324, v_85); seed.full(232, v_86); seed.full(240, v_87); seed.u8(325, v_88); seed.u8(326, v_89); seed.u8(327, v_90); seed.u8(328, v_91); seed.u8(329, v_92); seed.u8(330, v_93); seed.full(248, v_94); seed.u32(268, v_95); Ok(()) }, } }, _ => { Err(no_match(303, v_2)) }, } } + +fn write_303(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 47] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 48] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95]: [G; 45] = [G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 49] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_95.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(303, v_2)) }, } } + +static SCHEMA_303: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 256, 8, 272, 273, 274, 16, 24, 32, 275, 276, 277, 278, 279, 40, 48, 56, 280, 281, 282, 283, 284, 64, 72, 80, 285, 286, 287, 288, 289, 88, 96, 104, 290, 291, 292, 293, 294, 295, 112, 120, 296, 297, 298, 299, 300, 301, 128, 260, 264, 302, 303, 136, 144, 152, 304, 305, 306, 307, 308, 160, 168, 176, 309, 310, 311, 312, 313, 184, 192, 200, 314, 315, 316, 317, 318, 208, 216, 224, 319, 320, 321, 322, 323, 324, 232, 240, 325, 326, 327, 328, 329, 330, 248, 268], bytes: 336 }; + +fn pack_305(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47]: [G; 45] = context.call::<45>(0, 303, &[v_0, v_2])?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); let [v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 8] = context.call::<8>(1, 304, &[v_2])?; seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 45] = 'yield_0: { match v_3.as_canonical_u64() { 0u64 => { let [v_56]: [G; 1] = [G::from_u64(7)]; let [v_57]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_56, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57]; }, 1u64 => { let [v_58]: [G; 1] = [G::from_u64(6)]; let [v_59]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_58, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59]; }, 2u64 => { let [v_60]: [G; 1] = [G::from_u64(5)]; let [v_61]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_60, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61]; }, _ => { return Err(no_match(305, v_3)); }, } }; let [v_107]: [G; 1] = [G::from_u64(1)]; let [v_108]: [G; 1] = context.store(9, &[v_107, v_107, v_107])?; seed[57] = v_108.as_canonical_u64(); let [v_109]: [G; 1] = context.call::<1>(10, 79, &[v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_108, v_108, v_108, v_108])?; seed[58] = v_109.as_canonical_u64(); let [v_110]: [G; 1] = context.returned::<1>(11)?; seed[59] = v_110.as_canonical_u64(); Ok(()) } + +fn pack_305_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47]: [G; 45] = context.call::<45>(0, 303, &[v_0, v_2])?; seed.u8(157, v_3); seed.u8(158, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(159, v_8); seed.u8(160, v_9); seed.u8(161, v_10); seed.u8(162, v_11); seed.u8(163, v_12); seed.full(40, v_13); seed.full(48, v_14); seed.full(56, v_15); seed.u8(164, v_16); seed.u8(165, v_17); seed.u8(166, v_18); seed.u8(167, v_19); seed.u8(168, v_20); seed.full(64, v_21); seed.full(72, v_22); seed.full(80, v_23); seed.u8(169, v_24); seed.u8(170, v_25); seed.u8(171, v_26); seed.u8(172, v_27); seed.u8(173, v_28); seed.full(88, v_29); seed.full(96, v_30); seed.full(104, v_31); seed.u8(174, v_32); seed.u8(175, v_33); seed.u8(176, v_34); seed.u8(177, v_35); seed.u8(178, v_36); seed.u8(179, v_37); seed.full(112, v_38); seed.full(120, v_39); seed.u8(180, v_40); seed.u8(181, v_41); seed.u8(182, v_42); seed.u8(183, v_43); seed.u8(184, v_44); seed.u8(185, v_45); seed.full(128, v_46); seed.u32(140, v_47); let [v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 8] = context.call::<8>(1, 304, &[v_2])?; seed.u8(186, v_48); seed.u8(187, v_49); seed.u8(188, v_50); seed.u8(189, v_51); seed.u8(190, v_52); seed.u8(191, v_53); seed.u8(192, v_54); seed.u8(193, v_55); let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 45] = 'yield_0: { match v_3.as_canonical_u64() { 0u64 => { let [v_56]: [G; 1] = [G::from_u64(7)]; let [v_57]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_56, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57]; }, 1u64 => { let [v_58]: [G; 1] = [G::from_u64(6)]; let [v_59]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_58, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59]; }, 2u64 => { let [v_60]: [G; 1] = [G::from_u64(5)]; let [v_61]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_60, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61]; }, _ => { return Err(no_match(305, v_3)); }, } }; let [v_107]: [G; 1] = [G::from_u64(1)]; let [v_108]: [G; 1] = context.store(9, &[v_107, v_107, v_107])?; seed.u32(144, v_108); let [v_109]: [G; 1] = context.call::<1>(10, 79, &[v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_108, v_108, v_108, v_108])?; seed.u32(148, v_109); let [v_110]: [G; 1] = context.returned::<1>(11)?; seed.u32(152, v_110); Ok(()) } + +fn write_305(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47]: [G; 45] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); let [v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 8] = [G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56])]; row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_55.as_canonical_u64(); let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 45] = 'yield_0: { match v_3.as_canonical_u64() { 0u64 => { let [v_56]: [G; 1] = [G::from_u64(7)]; let [v_57]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_56, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57]; }, 1u64 => { let [v_58]: [G; 1] = [G::from_u64(6)]; let [v_59]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_58, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59]; }, 2u64 => { let [v_60]: [G; 1] = [G::from_u64(5)]; let [v_61]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_60, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61]; }, _ => { return Err(no_match(305, v_3)); }, } }; row[offsets.auxiliaries + 54] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_106.as_canonical_u64(); let [v_108]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 99] = v_108.as_canonical_u64(); let [v_109]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 100] = v_109.as_canonical_u64(); let [v_110]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 101] = v_110.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) } + +static SCHEMA_305: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 136, 156, 8, 157, 158, 16, 24, 32, 159, 160, 161, 162, 163, 40, 48, 56, 164, 165, 166, 167, 168, 64, 72, 80, 169, 170, 171, 172, 173, 88, 96, 104, 174, 175, 176, 177, 178, 179, 112, 120, 180, 181, 182, 183, 184, 185, 128, 140, 186, 187, 188, 189, 190, 191, 192, 193, 144, 148, 152], bytes: 200 }; + +fn pack_352(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_10]: [G; 1] = context.call::<1>(6, 352, &[v_2])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(7, 352, &[v_3])?; seed[7] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = context.returned::<1>(8)?; seed[8] = v_12.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = context.call::<1>(9, 352, &[v_2])?; seed[6] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(10, 352, &[v_3])?; seed[7] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.call::<1>(11, 355, &[v_14])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.returned::<1>(12)?; seed[9] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.call::<1>(13, 352, &[v_2])?; seed[6] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(14, 352, &[v_3])?; seed[7] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(15, 355, &[v_18])?; seed[8] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.returned::<1>(16)?; seed[9] = v_20.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = context.returned::<1>(17)?; seed[6] = v_21.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = context.returned::<1>(18)?; seed[6] = v_22.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(352, v_1)) }, } } + +fn pack_352_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(56, v_1); seed.u32(44, v_2); seed.u32(48, v_3); seed.u32(52, v_4); match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_10]: [G; 1] = context.call::<1>(6, 352, &[v_2])?; seed.full(8, v_10); let [v_11]: [G; 1] = context.call::<1>(7, 352, &[v_3])?; seed.full(16, v_11); let [v_12]: [G; 1] = context.returned::<1>(8)?; seed.full(24, v_12); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = context.call::<1>(9, 352, &[v_2])?; seed.full(8, v_13); let [v_14]: [G; 1] = context.call::<1>(10, 352, &[v_3])?; seed.full(16, v_14); let [v_15]: [G; 1] = context.call::<1>(11, 355, &[v_14])?; seed.full(24, v_15); let [v_16]: [G; 1] = context.returned::<1>(12)?; seed.full(32, v_16); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.call::<1>(13, 352, &[v_2])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(14, 352, &[v_3])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(15, 355, &[v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.returned::<1>(16)?; seed.full(32, v_20); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = context.returned::<1>(17)?; seed.full(8, v_21); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = context.returned::<1>(18)?; seed.full(8, v_22); Ok(()) }, _ => { Err(no_match(352, v_1)) }, } } + +fn write_352(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4]: [G; 4] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 8] = v_20.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_21]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(352, v_1)) }, } } + +static SCHEMA_352: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 40, 56, 44, 48, 52, 8, 16, 24, 32], bytes: 64 }; + +fn pack_357(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_13]: [G; 1] = context.call::<1>(7, 357, &[v_4, v_1, v_2])?; seed[8] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_15]: [G; 1] = context.returned::<1>(9)?; seed[9] = v_15.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(357, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(10)?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(11)?; seed[8] = v_17.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(12)?; seed[8] = v_18.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(13)?; seed[8] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(357, v_3)) }, } } + +fn pack_357_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(32, v_3); seed.u32(20, v_4); seed.u32(24, v_5); seed.u32(28, v_6); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_13]: [G; 1] = context.call::<1>(7, 357, &[v_4, v_1, v_2])?; seed.u8(33, v_13); match v_13.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_15]: [G; 1] = context.returned::<1>(9)?; seed.u8(34, v_15); Ok(()) }, _ => { Err(no_match(357, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(10)?; seed.u8(33, v_16); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(11)?; seed.u8(33, v_17); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(12)?; seed.u8(33, v_18); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(13)?; seed.u8(33, v_19); Ok(()) }, _ => { Err(no_match(357, v_3)) }, } } + +fn write_357(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6]: [G; 4] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_1); let [v_7]: [G; 1] = [op_1.0]; row[offsets.auxiliaries + 5] = op_1.1[0].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_1.1[1].as_canonical_u64(); row[offsets.auxiliaries + 7] = op_1.1[2].as_canonical_u64(); row[offsets.auxiliaries + 8] = op_1.1[3].as_canonical_u64(); row[offsets.auxiliaries + 9] = op_1.1[4].as_canonical_u64(); row[offsets.auxiliaries + 10] = op_1.1[5].as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let op_3 = u32_less_than(v_4, v_2); let [v_9]: [G; 1] = [op_3.0]; row[offsets.auxiliaries + 11] = op_3.1[0].as_canonical_u64(); row[offsets.auxiliaries + 12] = op_3.1[1].as_canonical_u64(); row[offsets.auxiliaries + 13] = op_3.1[2].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_3.1[3].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_3.1[4].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_3.1[5].as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(357, v_7)) }, } }, 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(357, v_13)) }, } }, 4u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_18.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(357, v_3)) }, } } + +static SCHEMA_357: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 16, 32, 20, 24, 28, 33, 34], bytes: 40 }; + +fn pack_365(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 352, &[v_0])?; seed[3] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(1)]; let [v_4]: [G; 1] = [v_1 + v_3]; let [v_5]: [G; 1] = context.call::<1>(3, 0, &[v_2, v_4])?; seed[4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.returned::<1>(5)?; seed[5] = v_7.as_canonical_u64(); Ok(()) }, } } + +fn pack_365_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 352, &[v_0])?; seed.u32(24, v_2); let [v_3]: [G; 1] = [G::from_u64(1)]; let [v_4]: [G; 1] = [v_1 + v_3]; let [v_5]: [G; 1] = context.call::<1>(3, 0, &[v_2, v_4])?; seed.u8(28, v_5); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.returned::<1>(5)?; seed.full(8, v_7); Ok(()) }, } } + +fn write_365(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_365: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 16, 20, 24, 28, 8], bytes: 32 }; + +fn pack_366(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 0, &[v_3, v_1])?; seed[7] = v_6.as_canonical_u64(); Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_12]: [G; 1] = context.call::<1>(7, 365, &[v_3, v_1])?; seed[7] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_14]: [G; 1] = context.call::<1>(9, 365, &[v_4, v_1])?; seed[8] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.returned::<1>(10)?; seed[9] = v_15.as_canonical_u64(); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(11)?; seed[7] = v_16.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(12)?; seed[7] = v_17.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(13)?; seed[7] = v_18.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(14)?; seed[7] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(366, v_2)) }, } } + +fn pack_366_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(48, v_2); seed.u32(32, v_3); seed.u32(36, v_4); seed.u32(40, v_5); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 0, &[v_3, v_1])?; seed.full(8, v_6); Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_12]: [G; 1] = context.call::<1>(7, 365, &[v_3, v_1])?; seed.full(8, v_12); match v_12.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_14]: [G; 1] = context.call::<1>(9, 365, &[v_4, v_1])?; seed.u32(44, v_14); let [v_15]: [G; 1] = context.returned::<1>(10)?; seed.full(16, v_15); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = context.returned::<1>(11)?; seed.full(8, v_16); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = context.returned::<1>(12)?; seed.full(8, v_17); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = context.returned::<1>(13)?; seed.full(8, v_18); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = context.returned::<1>(14)?; seed.full(8, v_19); Ok(()) }, _ => { Err(no_match(366, v_2)) }, } } + +fn write_366(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5]: [G; 4] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); match v_6.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(366, v_6)) }, } }, 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 6] = (v_12 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 4u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_18.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_19]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(366, v_2)) }, } } + +static SCHEMA_366: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 24, 28, 48, 32, 36, 40, 8, 44, 16], bytes: 56 }; + +fn pack_373(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3]: [G; 1] = context.call::<1>(0, 352, &[v_0])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.call::<1>(1, 0, &[v_2, v_3])?; seed[5] = v_4.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed[6] = v_5.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(373, v_4)) }, } }, } } + +fn pack_373_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_3]: [G; 1] = context.call::<1>(0, 352, &[v_0])?; seed.u32(32, v_3); let [v_4]: [G; 1] = context.call::<1>(1, 0, &[v_2, v_3])?; seed.u8(36, v_4); match v_4.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed.full(16, v_5); Ok(()) }, _ => { Err(no_match(373, v_4)) }, } }, } } + +fn write_373(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_5]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(373, v_4)) }, } }, } } + +static SCHEMA_373: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 8, 28, 32, 36, 16], bytes: 40 }; + +fn pack_374(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [v_4 - v_1]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_9, v_8, v_8])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(374, v_7)) }, } }, 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_12, v_12])?; seed[8] = v_13.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_14]: [G; 1] = [G::from_u64(2)]; let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.store(10, &[v_14, v_4, v_5, v_15])?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_17]: [G; 1] = [G::from_u64(3)]; let [v_18]: [G; 1] = context.call::<1>(12, 373, &[v_4, v_1, v_2])?; seed[8] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(13, 373, &[v_5, v_1, v_2])?; seed[9] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = context.store(15, &[v_17, v_18, v_19, v_20])?; seed[10] = v_21.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_22]: [G; 1] = [G::from_u64(4)]; let [v_23]: [G; 1] = context.call::<1>(17, 373, &[v_4, v_1, v_2])?; seed[8] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_2 + v_24]; let [v_26]: [G; 1] = context.call::<1>(20, 373, &[v_5, v_1, v_25])?; seed[9] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(0)]; let [v_28]: [G; 1] = context.store(22, &[v_22, v_23, v_26, v_27])?; seed[10] = v_28.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_29]: [G; 1] = [G::from_u64(5)]; let [v_30]: [G; 1] = context.call::<1>(24, 373, &[v_4, v_1, v_2])?; seed[8] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = [v_2 + v_31]; let [v_33]: [G; 1] = context.call::<1>(27, 373, &[v_5, v_1, v_32])?; seed[9] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(29, &[v_29, v_30, v_33, v_34])?; seed[10] = v_35.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_36]: [G; 1] = [G::from_u64(6)]; let [v_37]: [G; 1] = context.call::<1>(31, 373, &[v_4, v_1, v_2])?; seed[8] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = context.call::<1>(32, 373, &[v_5, v_1, v_2])?; seed[9] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(1)]; let [v_40]: [G; 1] = [v_2 + v_39]; let [v_41]: [G; 1] = context.call::<1>(35, 373, &[v_6, v_1, v_40])?; seed[10] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.store(36, &[v_36, v_37, v_38, v_41])?; seed[11] = v_42.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_43]: [G; 1] = [G::from_u64(7)]; let [v_44]: [G; 1] = [G::from_u64(0)]; let [v_45]: [G; 1] = context.store(39, &[v_43, v_4, v_5, v_44])?; seed[8] = v_45.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_46]: [G; 1] = [G::from_u64(8)]; let [v_47]: [G; 1] = context.call::<1>(41, 373, &[v_6, v_1, v_2])?; seed[8] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.store(42, &[v_46, v_4, v_5, v_47])?; seed[9] = v_48.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(374, v_3)) }, } } + +fn pack_374_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(64, v_3); seed.u32(48, v_4); seed.u32(52, v_5); seed.u32(56, v_6); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [v_4 - v_1]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_9, v_8, v_8])?; seed.full(16, v_10); Ok(()) }, _ => { Err(no_match(374, v_7)) }, } }, 1u64 => { let [v_11]: [G; 1] = [G::from_u64(1)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_12, v_12])?; seed.full(16, v_13); Ok(()) }, 2u64 => { let [v_14]: [G; 1] = [G::from_u64(2)]; let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.store(10, &[v_14, v_4, v_5, v_15])?; seed.full(16, v_16); Ok(()) }, 3u64 => { let [v_17]: [G; 1] = [G::from_u64(3)]; let [v_18]: [G; 1] = context.call::<1>(12, 373, &[v_4, v_1, v_2])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(13, 373, &[v_5, v_1, v_2])?; seed.full(24, v_19); let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = context.store(15, &[v_17, v_18, v_19, v_20])?; seed.full(32, v_21); Ok(()) }, 4u64 => { let [v_22]: [G; 1] = [G::from_u64(4)]; let [v_23]: [G; 1] = context.call::<1>(17, 373, &[v_4, v_1, v_2])?; seed.full(16, v_23); let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_2 + v_24]; let [v_26]: [G; 1] = context.call::<1>(20, 373, &[v_5, v_1, v_25])?; seed.full(24, v_26); let [v_27]: [G; 1] = [G::from_u64(0)]; let [v_28]: [G; 1] = context.store(22, &[v_22, v_23, v_26, v_27])?; seed.full(32, v_28); Ok(()) }, 5u64 => { let [v_29]: [G; 1] = [G::from_u64(5)]; let [v_30]: [G; 1] = context.call::<1>(24, 373, &[v_4, v_1, v_2])?; seed.full(16, v_30); let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = [v_2 + v_31]; let [v_33]: [G; 1] = context.call::<1>(27, 373, &[v_5, v_1, v_32])?; seed.full(24, v_33); let [v_34]: [G; 1] = [G::from_u64(0)]; let [v_35]: [G; 1] = context.store(29, &[v_29, v_30, v_33, v_34])?; seed.full(32, v_35); Ok(()) }, 6u64 => { let [v_36]: [G; 1] = [G::from_u64(6)]; let [v_37]: [G; 1] = context.call::<1>(31, 373, &[v_4, v_1, v_2])?; seed.full(16, v_37); let [v_38]: [G; 1] = context.call::<1>(32, 373, &[v_5, v_1, v_2])?; seed.full(24, v_38); let [v_39]: [G; 1] = [G::from_u64(1)]; let [v_40]: [G; 1] = [v_2 + v_39]; let [v_41]: [G; 1] = context.call::<1>(35, 373, &[v_6, v_1, v_40])?; seed.full(32, v_41); let [v_42]: [G; 1] = context.store(36, &[v_36, v_37, v_38, v_41])?; seed.u32(60, v_42); Ok(()) }, 7u64 => { let [v_43]: [G; 1] = [G::from_u64(7)]; let [v_44]: [G; 1] = [G::from_u64(0)]; let [v_45]: [G; 1] = context.store(39, &[v_43, v_4, v_5, v_44])?; seed.full(16, v_45); Ok(()) }, 8u64 => { let [v_46]: [G; 1] = [G::from_u64(8)]; let [v_47]: [G; 1] = context.call::<1>(41, 373, &[v_6, v_1, v_2])?; seed.full(16, v_47); let [v_48]: [G; 1] = context.store(42, &[v_46, v_4, v_5, v_47])?; seed.full(24, v_48); Ok(()) }, _ => { Err(no_match(374, v_3)) }, } } + +fn write_374(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6]: [G; 4] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let op_1 = u32_less_than(v_4, v_2); let [v_7]: [G; 1] = [op_1.0]; row[offsets.auxiliaries + 5] = op_1.1[0].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_1.1[1].as_canonical_u64(); row[offsets.auxiliaries + 7] = op_1.1[2].as_canonical_u64(); row[offsets.auxiliaries + 8] = op_1.1[3].as_canonical_u64(); row[offsets.auxiliaries + 9] = op_1.1[4].as_canonical_u64(); row[offsets.auxiliaries + 10] = op_1.1[5].as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 11] = v_10.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(374, v_7)) }, } }, 1u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_19.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_21.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_23]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_26.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_28.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_30]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_30.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_33.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_35.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_37]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_38.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_42.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_45]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_45.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_47]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_48.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(374, v_3)) }, } } + +static SCHEMA_374: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 40, 8, 44, 64, 48, 52, 56, 16, 24, 32, 60], bytes: 72 }; + +fn pack_380(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 0, &[v_0, v_2])?; seed[4] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.store(2, &[v_4, v_0, v_4, v_4])?; seed[5] = v_5.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed[5] = v_8.as_canonical_u64(); Ok(()) }, _ => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [v_0 - v_10]; let [v_12]: [G; 1] = context.store(9, &[v_9, v_11, v_9, v_9])?; seed[5] = v_12.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(380, v_3)) }, } } + +fn pack_380_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 0, &[v_0, v_2])?; seed.u8(28, v_3); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.store(2, &[v_4, v_0, v_4, v_4])?; seed.full(8, v_5); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed.full(8, v_8); Ok(()) }, _ => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [v_0 - v_10]; let [v_12]: [G; 1] = context.store(9, &[v_9, v_11, v_9, v_9])?; seed.full(8, v_12); Ok(()) }, } }, _ => { Err(no_match(380, v_3)) }, } } + +fn write_380(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_0 - v_2]; match v_6.as_canonical_u64() { 0u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_8.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 2] = (v_6 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(380, v_3)) }, } } + +static SCHEMA_380: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 16, 20, 24, 28, 8], bytes: 32 }; + +fn pack_382(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 790, &[v_1])?; seed[4] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(1, 352, &[v_0])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_2, v_4])?; seed[6] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_6]: [G; 1] = [v_2 + v_3]; let [v_7]: [G; 1] = context.call::<1>(4, 357, &[v_0, v_2, v_6])?; seed[7] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed[8] = v_8.as_canonical_u64(); Ok(()) }, _ => { let [v_10]: [G; 1] = context.returned::<1>(7)?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(382, v_5)) }, } }, } } + +fn pack_382_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 790, &[v_1])?; seed.full(8, v_3); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(1, 352, &[v_0])?; seed.u32(36, v_4); let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_2, v_4])?; seed.u8(40, v_5); match v_5.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_6]: [G; 1] = [v_2 + v_3]; let [v_7]: [G; 1] = context.call::<1>(4, 357, &[v_0, v_2, v_6])?; seed.u8(41, v_7); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.returned::<1>(5)?; seed.full(16, v_8); Ok(()) }, _ => { let [v_10]: [G; 1] = context.returned::<1>(7)?; seed.full(16, v_10); Ok(()) }, } }, _ => { Err(no_match(382, v_5)) }, } }, } } + +fn write_382(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 2] = (v_3 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 6] = (v_7 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(382, v_5)) }, } }, } } + +static SCHEMA_382: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 28, 32, 8, 36, 40, 41, 16], bytes: 48 }; + +fn pack_383(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 790, &[v_1])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [v_0 - v_2]; let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_4, v_3])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(3, 792, &[v_1, v_4])?; seed[6] = v_6.as_canonical_u64(); let [v_8]: [G; 1] = context.returned::<1>(5)?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [v_0 - v_3]; let [v_11]: [G; 1] = context.store(8, &[v_9, v_10, v_9, v_9])?; seed[6] = v_11.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(383, v_5)) }, } } + +fn pack_383_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 790, &[v_1])?; seed.u32(36, v_3); let [v_4]: [G; 1] = [v_0 - v_2]; let [v_5]: [G; 1] = context.call::<1>(2, 0, &[v_4, v_3])?; seed.u8(44, v_5); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(3, 792, &[v_1, v_4])?; seed.u32(40, v_6); let [v_8]: [G; 1] = context.returned::<1>(5)?; seed.full(24, v_8); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = [v_0 - v_3]; let [v_11]: [G; 1] = context.store(8, &[v_9, v_10, v_9, v_9])?; seed.u32(40, v_11); Ok(()) }, _ => { Err(no_match(383, v_5)) }, } } + +fn write_383(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_8.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(383, v_5)) }, } } + +static SCHEMA_383: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 8, 32, 16, 36, 44, 40, 24], bytes: 48 }; + +fn pack_384(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = context.returned::<1>(1)?; seed[8] = v_7.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_4, v_9, v_9])?; seed[8] = v_10.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_11]: [G; 1] = [G::from_u64(2)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_5, v_12])?; seed[8] = v_13.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_14]: [G; 1] = [G::from_u64(3)]; let [v_15]: [G; 1] = context.call::<1>(9, 382, &[v_4, v_1, v_2])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(10, 382, &[v_5, v_1, v_2])?; seed[9] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(12, &[v_14, v_15, v_16, v_17])?; seed[10] = v_18.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_19]: [G; 1] = [G::from_u64(4)]; let [v_20]: [G; 1] = context.call::<1>(14, 382, &[v_4, v_1, v_2])?; seed[8] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(1)]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = context.call::<1>(17, 382, &[v_5, v_1, v_22])?; seed[9] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(19, &[v_19, v_20, v_23, v_24])?; seed[10] = v_25.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = context.call::<1>(21, 382, &[v_4, v_1, v_2])?; seed[8] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = [v_2 + v_28]; let [v_30]: [G; 1] = context.call::<1>(24, 382, &[v_5, v_1, v_29])?; seed[9] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(26, &[v_26, v_27, v_30, v_31])?; seed[10] = v_32.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = context.returned::<1>(27)?; seed[8] = v_33.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_34]: [G; 1] = [G::from_u64(7)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(30, &[v_34, v_4, v_5, v_35])?; seed[8] = v_36.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_37]: [G; 1] = [G::from_u64(8)]; let [v_38]: [G; 1] = context.call::<1>(32, 382, &[v_6, v_1, v_2])?; seed[8] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(33, &[v_37, v_4, v_5, v_38])?; seed[9] = v_39.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(384, v_3)) }, } } + +fn pack_384_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(52, v_3); seed.u32(36, v_4); seed.u32(40, v_5); seed.u32(44, v_6); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = context.returned::<1>(1)?; seed.full(8, v_7); Ok(()) }, 1u64 => { let [v_8]: [G; 1] = [G::from_u64(1)]; let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.store(4, &[v_8, v_4, v_9, v_9])?; seed.full(8, v_10); Ok(()) }, 2u64 => { let [v_11]: [G; 1] = [G::from_u64(2)]; let [v_12]: [G; 1] = [G::from_u64(0)]; let [v_13]: [G; 1] = context.store(7, &[v_11, v_4, v_5, v_12])?; seed.full(8, v_13); Ok(()) }, 3u64 => { let [v_14]: [G; 1] = [G::from_u64(3)]; let [v_15]: [G; 1] = context.call::<1>(9, 382, &[v_4, v_1, v_2])?; seed.full(8, v_15); let [v_16]: [G; 1] = context.call::<1>(10, 382, &[v_5, v_1, v_2])?; seed.full(16, v_16); let [v_17]: [G; 1] = [G::from_u64(0)]; let [v_18]: [G; 1] = context.store(12, &[v_14, v_15, v_16, v_17])?; seed.u32(48, v_18); Ok(()) }, 4u64 => { let [v_19]: [G; 1] = [G::from_u64(4)]; let [v_20]: [G; 1] = context.call::<1>(14, 382, &[v_4, v_1, v_2])?; seed.full(8, v_20); let [v_21]: [G; 1] = [G::from_u64(1)]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = context.call::<1>(17, 382, &[v_5, v_1, v_22])?; seed.full(16, v_23); let [v_24]: [G; 1] = [G::from_u64(0)]; let [v_25]: [G; 1] = context.store(19, &[v_19, v_20, v_23, v_24])?; seed.u32(48, v_25); Ok(()) }, 5u64 => { let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = context.call::<1>(21, 382, &[v_4, v_1, v_2])?; seed.full(8, v_27); let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = [v_2 + v_28]; let [v_30]: [G; 1] = context.call::<1>(24, 382, &[v_5, v_1, v_29])?; seed.full(16, v_30); let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(26, &[v_26, v_27, v_30, v_31])?; seed.u32(48, v_32); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = context.returned::<1>(27)?; seed.full(8, v_33); Ok(()) }, 7u64 => { let [v_34]: [G; 1] = [G::from_u64(7)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(30, &[v_34, v_4, v_5, v_35])?; seed.full(8, v_36); Ok(()) }, 8u64 => { let [v_37]: [G; 1] = [G::from_u64(8)]; let [v_38]: [G; 1] = context.call::<1>(32, 382, &[v_6, v_1, v_2])?; seed.full(8, v_38); let [v_39]: [G; 1] = context.store(33, &[v_37, v_4, v_5, v_38])?; seed.full(16, v_39); Ok(()) }, _ => { Err(no_match(384, v_3)) }, } } + +fn write_384(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6]: [G; 4] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_18.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_27]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_27.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_32.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_33]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_33.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_36]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_36.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_39.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(384, v_3)) }, } } + +static SCHEMA_384: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 24, 28, 32, 52, 36, 40, 44, 8, 16, 48], bytes: 56 }; + +fn pack_396(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4]: [G; 1] = context.call::<1>(0, 390, &[])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_4])?; seed[6] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6, v_6])?; seed[7] = v_7.as_canonical_u64(); Ok(()) }, _ => { match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = context.load::<4>(4, v_2)?; seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 391, &[])?; seed[11] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_9, v_12])?; seed[12] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(8, &[v_14, v_14, v_14, v_14])?; seed[13] = v_15.as_canonical_u64(); Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(9, 790, &[v_3])?; seed[13] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; match v_18.as_canonical_u64() { 1u64 => { let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(13, &[v_19, v_19, v_19, v_19])?; seed[14] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.call::<1>(15, 792, &[v_3, v_21])?; seed[14] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.call::<1>(17, 792, &[v_3, v_23])?; seed[15] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(2)]; let [v_26]: [G; 1] = context.call::<1>(19, 792, &[v_3, v_25])?; seed[16] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(3)]; let [v_28]: [G; 1] = context.call::<1>(21, 792, &[v_3, v_27])?; seed[17] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(4)]; let [v_30]: [G; 1] = context.call::<1>(23, 792, &[v_3, v_29])?; seed[18] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34]: [G; 4] = context.load::<4>(24, v_24)?; seed[19] = v_31.as_canonical_u64(); seed[20] = v_32.as_canonical_u64(); seed[21] = v_33.as_canonical_u64(); seed[22] = v_34.as_canonical_u64(); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = context.load::<4>(25, v_26)?; seed[23] = v_35.as_canonical_u64(); seed[24] = v_36.as_canonical_u64(); seed[25] = v_37.as_canonical_u64(); seed[26] = v_38.as_canonical_u64(); match v_35.as_canonical_u64() { 4u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.store(27, &[v_39, v_0, v_1, v_37])?; seed[27] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(4)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(30, &[v_41, v_36, v_40, v_42])?; seed[28] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47]: [G; 4] = context.load::<4>(31, v_28)?; seed[29] = v_44.as_canonical_u64(); seed[30] = v_45.as_canonical_u64(); seed[31] = v_46.as_canonical_u64(); seed[32] = v_47.as_canonical_u64(); match v_44.as_canonical_u64() { 4u64 => { let [v_48]: [G; 1] = [G::from_u64(8)]; let [v_49]: [G; 1] = context.store(33, &[v_48, v_0, v_1, v_46])?; seed[33] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(4)]; let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.store(36, &[v_50, v_45, v_49, v_51])?; seed[34] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(2)]; let [v_54]: [G; 1] = context.call::<1>(38, 392, &[])?; seed[35] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.store(40, &[v_55, v_55, v_55])?; seed[36] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.store(41, &[v_53, v_54, v_56, v_51])?; seed[37] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.store(42, &[v_50, v_32, v_57, v_51])?; seed[38] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.store(43, &[v_53, v_9, v_10, v_51])?; seed[39] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(3)]; let [v_61]: [G; 1] = context.store(45, &[v_60, v_59, v_22, v_51])?; seed[40] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = context.store(46, &[v_60, v_61, v_58, v_51])?; seed[41] = v_62.as_canonical_u64(); let [v_63]: [G; 1] = context.store(47, &[v_60, v_62, v_43, v_51])?; seed[42] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = context.store(48, &[v_60, v_63, v_52, v_51])?; seed[43] = v_64.as_canonical_u64(); let [v_65]: [G; 1] = context.store(49, &[v_60, v_64, v_30, v_51])?; seed[44] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(5)]; let [v_67]: [G; 1] = context.call::<1>(51, 801, &[v_3, v_66])?; seed[45] = v_67.as_canonical_u64(); let [v_68]: [G; 1] = context.call::<1>(52, 266, &[v_65, v_67])?; seed[46] = v_68.as_canonical_u64(); Ok(()) }, _ => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70]: [G; 1] = context.store(54, &[v_69, v_69, v_69, v_69])?; seed[33] = v_70.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_71]: [G; 1] = [G::from_u64(0)]; let [v_72]: [G; 1] = context.store(56, &[v_71, v_71, v_71, v_71])?; seed[27] = v_72.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_73]: [G; 1] = [G::from_u64(0)]; let [v_74]: [G; 1] = context.store(58, &[v_73, v_73, v_73, v_73])?; seed[23] = v_74.as_canonical_u64(); Ok(()) }, } }, } }, } }, _ => { let [v_75]: [G; 1] = [G::from_u64(0)]; let [v_76]: [G; 1] = context.store(60, &[v_75, v_75, v_75, v_75])?; seed[11] = v_76.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_77]: [G; 1] = [G::from_u64(0)]; let [v_78]: [G; 1] = context.store(62, &[v_77, v_77, v_77, v_77])?; seed[7] = v_78.as_canonical_u64(); Ok(()) }, } }, } } + +fn pack_396_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4]: [G; 1] = context.call::<1>(0, 390, &[])?; seed.u32(140, v_4); let [v_5]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_4])?; seed.u8(236, v_5); match v_5.as_canonical_u64() { 0u64 => { let [v_6]: [G; 1] = [G::from_u64(0)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6, v_6])?; seed.u32(144, v_7); Ok(()) }, _ => { match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = context.load::<4>(4, v_2)?; seed.u32(144, v_8); seed.u32(148, v_9); seed.full(16, v_10); seed.full(24, v_11); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 391, &[])?; seed.u32(152, v_12); let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_9, v_12])?; seed.u8(237, v_13); match v_13.as_canonical_u64() { 0u64 => { let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(8, &[v_14, v_14, v_14, v_14])?; seed.u32(156, v_15); Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(9, 790, &[v_3])?; seed.u32(156, v_16); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; match v_18.as_canonical_u64() { 1u64 => { let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(13, &[v_19, v_19, v_19, v_19])?; seed.full(32, v_20); Ok(()) }, _ => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.call::<1>(15, 792, &[v_3, v_21])?; seed.full(32, v_22); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.call::<1>(17, 792, &[v_3, v_23])?; seed.u32(160, v_24); let [v_25]: [G; 1] = [G::from_u64(2)]; let [v_26]: [G; 1] = context.call::<1>(19, 792, &[v_3, v_25])?; seed.u32(164, v_26); let [v_27]: [G; 1] = [G::from_u64(3)]; let [v_28]: [G; 1] = context.call::<1>(21, 792, &[v_3, v_27])?; seed.u32(168, v_28); let [v_29]: [G; 1] = [G::from_u64(4)]; let [v_30]: [G; 1] = context.call::<1>(23, 792, &[v_3, v_29])?; seed.full(40, v_30); let [v_31, v_32, v_33, v_34]: [G; 4] = context.load::<4>(24, v_24)?; seed.u8(238, v_31); seed.full(48, v_32); seed.full(56, v_33); seed.full(64, v_34); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = context.load::<4>(25, v_26)?; seed.u32(172, v_35); seed.full(72, v_36); seed.full(80, v_37); seed.full(88, v_38); match v_35.as_canonical_u64() { 4u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.store(27, &[v_39, v_0, v_1, v_37])?; seed.u32(176, v_40); let [v_41]: [G; 1] = [G::from_u64(4)]; let [v_42]: [G; 1] = [G::from_u64(0)]; let [v_43]: [G; 1] = context.store(30, &[v_41, v_36, v_40, v_42])?; seed.u32(180, v_43); let [v_44, v_45, v_46, v_47]: [G; 4] = context.load::<4>(31, v_28)?; seed.u8(239, v_44); seed.full(96, v_45); seed.full(104, v_46); seed.full(112, v_47); match v_44.as_canonical_u64() { 4u64 => { let [v_48]: [G; 1] = [G::from_u64(8)]; let [v_49]: [G; 1] = context.store(33, &[v_48, v_0, v_1, v_46])?; seed.u32(184, v_49); let [v_50]: [G; 1] = [G::from_u64(4)]; let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.store(36, &[v_50, v_45, v_49, v_51])?; seed.u32(188, v_52); let [v_53]: [G; 1] = [G::from_u64(2)]; let [v_54]: [G; 1] = context.call::<1>(38, 392, &[])?; seed.u32(192, v_54); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.store(40, &[v_55, v_55, v_55])?; seed.u32(196, v_56); let [v_57]: [G; 1] = context.store(41, &[v_53, v_54, v_56, v_51])?; seed.u32(200, v_57); let [v_58]: [G; 1] = context.store(42, &[v_50, v_32, v_57, v_51])?; seed.u32(204, v_58); let [v_59]: [G; 1] = context.store(43, &[v_53, v_9, v_10, v_51])?; seed.u32(208, v_59); let [v_60]: [G; 1] = [G::from_u64(3)]; let [v_61]: [G; 1] = context.store(45, &[v_60, v_59, v_22, v_51])?; seed.u32(212, v_61); let [v_62]: [G; 1] = context.store(46, &[v_60, v_61, v_58, v_51])?; seed.u32(216, v_62); let [v_63]: [G; 1] = context.store(47, &[v_60, v_62, v_43, v_51])?; seed.u32(220, v_63); let [v_64]: [G; 1] = context.store(48, &[v_60, v_63, v_52, v_51])?; seed.u32(224, v_64); let [v_65]: [G; 1] = context.store(49, &[v_60, v_64, v_30, v_51])?; seed.u32(228, v_65); let [v_66]: [G; 1] = [G::from_u64(5)]; let [v_67]: [G; 1] = context.call::<1>(51, 801, &[v_3, v_66])?; seed.u32(232, v_67); let [v_68]: [G; 1] = context.call::<1>(52, 266, &[v_65, v_67])?; seed.full(120, v_68); Ok(()) }, _ => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [v_70]: [G; 1] = context.store(54, &[v_69, v_69, v_69, v_69])?; seed.u32(184, v_70); Ok(()) }, } }, _ => { let [v_71]: [G; 1] = [G::from_u64(0)]; let [v_72]: [G; 1] = context.store(56, &[v_71, v_71, v_71, v_71])?; seed.u32(176, v_72); Ok(()) }, } }, _ => { let [v_73]: [G; 1] = [G::from_u64(0)]; let [v_74]: [G; 1] = context.store(58, &[v_73, v_73, v_73, v_73])?; seed.u32(172, v_74); Ok(()) }, } }, } }, } }, _ => { let [v_75]: [G; 1] = [G::from_u64(0)]; let [v_76]: [G; 1] = context.store(60, &[v_75, v_75, v_75, v_75])?; seed.u32(152, v_76); Ok(()) }, } }, _ => { let [v_77]: [G; 1] = [G::from_u64(0)]; let [v_78]: [G; 1] = context.store(62, &[v_77, v_77, v_77, v_77])?; seed.u32(144, v_78); Ok(()) }, } }, } } + +fn write_396(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 3] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_5 - G::from_u64(0)).inverse().as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_8, v_9, v_10, v_11]: [G; 4] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 4] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_11.as_canonical_u64(); match v_8.as_canonical_u64() { 2u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 10] = (v_13 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(5)]; let op_11 = u32_less_than(v_16, v_17); let [v_18]: [G; 1] = [op_11.0]; row[offsets.auxiliaries + 12] = op_11.1[0].as_canonical_u64(); row[offsets.auxiliaries + 13] = op_11.1[1].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_11.1[2].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_11.1[3].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_11.1[4].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_11.1[5].as_canonical_u64(); match v_18.as_canonical_u64() { 1u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 18] = (v_18 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 20] = v_24.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 22] = v_28.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 23] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34]: [G; 4] = [G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 24] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_34.as_canonical_u64(); match v_31.as_canonical_u64() { 4u64 => { let [v_35, v_36, v_37, v_38]: [G; 4] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 28] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_38.as_canonical_u64(); match v_35.as_canonical_u64() { 4u64 => { let [v_40]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 32] = v_40.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 33] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47]: [G; 4] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 34] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_47.as_canonical_u64(); match v_44.as_canonical_u64() { 4u64 => { let [v_49]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 38] = v_49.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[34])]; row[offsets.auxiliaries + 39] = v_52.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[35])]; row[offsets.auxiliaries + 40] = v_54.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 41] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 42] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 43] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 44] = v_59.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_u64(seed[40])]; row[offsets.auxiliaries + 45] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(seed[41])]; row[offsets.auxiliaries + 46] = v_62.as_canonical_u64(); let [v_63]: [G; 1] = [G::from_u64(seed[42])]; row[offsets.auxiliaries + 47] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = [G::from_u64(seed[43])]; row[offsets.auxiliaries + 48] = v_64.as_canonical_u64(); let [v_65]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 49] = v_65.as_canonical_u64(); let [v_67]: [G; 1] = [G::from_u64(seed[45])]; row[offsets.auxiliaries + 50] = v_67.as_canonical_u64(); let [v_68]: [G; 1] = [G::from_u64(seed[46])]; row[offsets.auxiliaries + 51] = v_68.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 38] = (v_44 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_70]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 39] = v_70.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 32] = (v_35 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_72]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 33] = v_72.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 28] = (v_31 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_74]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 29] = v_74.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, } }, } }, _ => { row[offsets.auxiliaries + 8] = (v_8 - G::from_u64(2)).inverse().as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 9] = v_76.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 4] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_78]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_78.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, } } + +static SCHEMA_396: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 128, 8, 132, 136, 140, 236, 144, 148, 16, 24, 152, 237, 156, 32, 160, 164, 168, 40, 238, 48, 56, 64, 172, 72, 80, 88, 176, 180, 239, 96, 104, 112, 184, 188, 192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 120], bytes: 240 }; + +fn pack_401(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 159, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_3]; }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 160, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 173, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_9]; }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 174, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_12]; }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 175, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_15]; }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 179, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_18]; }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 178, &[])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed[15] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_21]; }, _ => { let [v_22]: [G; 1] = context.call::<1>(21, 176, &[])?; seed[16] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(22, 2, &[v_0, v_22])?; seed[17] = v_23.as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_24]; }, _ => { let [v_25]: [G; 1] = context.call::<1>(24, 177, &[])?; seed[18] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.call::<1>(25, 2, &[v_0, v_25])?; seed[19] = v_26.as_canonical_u64(); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_27]; }, _ => { let [v_28]: [G; 1] = context.call::<1>(27, 185, &[])?; seed[20] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.call::<1>(28, 2, &[v_0, v_28])?; seed[21] = v_29.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_30]; }, _ => { let [v_31]: [G; 1] = context.call::<1>(30, 186, &[])?; seed[22] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.call::<1>(31, 2, &[v_0, v_31])?; seed[23] = v_32.as_canonical_u64(); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_33]; }, _ => { let [v_34]: [G; 1] = context.call::<1>(33, 180, &[])?; seed[24] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.call::<1>(34, 2, &[v_0, v_34])?; seed[25] = v_35.as_canonical_u64(); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_36]; }, _ => { let [v_37]: [G; 1] = context.call::<1>(36, 181, &[])?; seed[26] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = context.call::<1>(37, 2, &[v_0, v_37])?; seed[27] = v_38.as_canonical_u64(); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_39]; }, _ => { let [v_40]: [G; 1] = context.call::<1>(39, 182, &[])?; seed[28] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.call::<1>(40, 2, &[v_0, v_40])?; seed[29] = v_41.as_canonical_u64(); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_42]; }, _ => { let [v_43]: [G; 1] = context.call::<1>(42, 183, &[])?; seed[30] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(43, 2, &[v_0, v_43])?; seed[31] = v_44.as_canonical_u64(); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_45]; }, _ => { let [v_46]: [G; 1] = context.call::<1>(45, 184, &[])?; seed[32] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = context.call::<1>(46, 2, &[v_0, v_46])?; seed[33] = v_47.as_canonical_u64(); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_48]; }, _ => { let [v_49]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; match v_50.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_52]: [G; 1] = context.call::<1>(50, 230, &[v_0])?; seed[34] = v_52.as_canonical_u64(); match v_52.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_54]: [G; 1] = context.call::<1>(52, 208, &[v_0])?; seed[35] = v_54.as_canonical_u64(); match v_54.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_56]: [G; 1] = context.call::<1>(54, 195, &[v_0])?; seed[36] = v_56.as_canonical_u64(); match v_56.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_58]: [G; 1] = context.call::<1>(56, 536, &[v_0])?; seed[37] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_60]: [G; 1] = context.call::<1>(58, 253, &[v_0])?; seed[38] = v_60.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } } + +fn pack_401_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 159, &[])?; seed.u32(12, v_1); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed.u8(78, v_2); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_3]; }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 160, &[])?; seed.u32(16, v_4); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed.u8(79, v_5); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 173, &[])?; seed.u32(20, v_7); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed.u8(80, v_8); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_9]; }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 174, &[])?; seed.u32(24, v_10); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed.u8(81, v_11); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_12]; }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 175, &[])?; seed.u32(28, v_13); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed.u8(82, v_14); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_15]; }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 179, &[])?; seed.u32(32, v_16); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed.u8(83, v_17); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_18]; }, _ => { let [v_19]: [G; 1] = context.call::<1>(18, 178, &[])?; seed.u32(36, v_19); let [v_20]: [G; 1] = context.call::<1>(19, 2, &[v_0, v_19])?; seed.u8(84, v_20); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_21]; }, _ => { let [v_22]: [G; 1] = context.call::<1>(21, 176, &[])?; seed.u32(40, v_22); let [v_23]: [G; 1] = context.call::<1>(22, 2, &[v_0, v_22])?; seed.u8(85, v_23); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_24]; }, _ => { let [v_25]: [G; 1] = context.call::<1>(24, 177, &[])?; seed.u32(44, v_25); let [v_26]: [G; 1] = context.call::<1>(25, 2, &[v_0, v_25])?; seed.u8(86, v_26); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_27]; }, _ => { let [v_28]: [G; 1] = context.call::<1>(27, 185, &[])?; seed.u32(48, v_28); let [v_29]: [G; 1] = context.call::<1>(28, 2, &[v_0, v_28])?; seed.u8(87, v_29); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_30]; }, _ => { let [v_31]: [G; 1] = context.call::<1>(30, 186, &[])?; seed.u32(52, v_31); let [v_32]: [G; 1] = context.call::<1>(31, 2, &[v_0, v_31])?; seed.u8(88, v_32); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_33]; }, _ => { let [v_34]: [G; 1] = context.call::<1>(33, 180, &[])?; seed.u32(56, v_34); let [v_35]: [G; 1] = context.call::<1>(34, 2, &[v_0, v_34])?; seed.u8(89, v_35); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_36]; }, _ => { let [v_37]: [G; 1] = context.call::<1>(36, 181, &[])?; seed.u32(60, v_37); let [v_38]: [G; 1] = context.call::<1>(37, 2, &[v_0, v_37])?; seed.u8(90, v_38); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_39]; }, _ => { let [v_40]: [G; 1] = context.call::<1>(39, 182, &[])?; seed.u32(64, v_40); let [v_41]: [G; 1] = context.call::<1>(40, 2, &[v_0, v_40])?; seed.u8(91, v_41); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_42]; }, _ => { let [v_43]: [G; 1] = context.call::<1>(42, 183, &[])?; seed.u32(68, v_43); let [v_44]: [G; 1] = context.call::<1>(43, 2, &[v_0, v_43])?; seed.u8(92, v_44); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_45]; }, _ => { let [v_46]: [G; 1] = context.call::<1>(45, 184, &[])?; seed.u32(72, v_46); let [v_47]: [G; 1] = context.call::<1>(46, 2, &[v_0, v_46])?; seed.u8(93, v_47); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_48]; }, _ => { let [v_49]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; match v_50.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_52]: [G; 1] = context.call::<1>(50, 230, &[v_0])?; seed.u8(94, v_52); match v_52.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_54]: [G; 1] = context.call::<1>(52, 208, &[v_0])?; seed.u8(95, v_54); match v_54.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_56]: [G; 1] = context.call::<1>(54, 195, &[v_0])?; seed.u8(96, v_56); match v_56.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_58]: [G; 1] = context.call::<1>(56, 536, &[v_0])?; seed.u8(97, v_58); match v_58.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_60]: [G; 1] = context.call::<1>(58, 253, &[v_0])?; seed.u16(76, v_60); Ok(()) }, } }, } }, } }, } }, } } + +fn write_401(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_50]: [G; 1] = 'yield_0: { match v_2.as_canonical_u64() { 1u64 => { let [v_3]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { row[offsets.auxiliaries + 3] = (v_2 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_6]; }, _ => { row[offsets.auxiliaries + 6] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_9]; }, _ => { row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { let [v_12]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_12]; }, _ => { row[offsets.auxiliaries + 12] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 [v_15]; }, _ => { row[offsets.auxiliaries + 15] = (v_14 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_18]; }, _ => { row[offsets.auxiliaries + 18] = (v_17 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); break 'yield_0 [v_21]; }, _ => { row[offsets.auxiliaries + 21] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); break 'yield_0 [v_24]; }, _ => { row[offsets.auxiliaries + 24] = (v_23 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); match v_26.as_canonical_u64() { 1u64 => { let [v_27]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); break 'yield_0 [v_27]; }, _ => { row[offsets.auxiliaries + 27] = (v_26 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); break 'yield_0 [v_30]; }, _ => { row[offsets.auxiliaries + 30] = (v_29 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); match v_32.as_canonical_u64() { 1u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); break 'yield_0 [v_33]; }, _ => { row[offsets.auxiliaries + 33] = (v_32 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[25])]; row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); match v_35.as_canonical_u64() { 1u64 => { let [v_36]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); break 'yield_0 [v_36]; }, _ => { row[offsets.auxiliaries + 36] = (v_35 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_37]: [G; 1] = [G::from_u64(seed[26])]; row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); match v_38.as_canonical_u64() { 1u64 => { let [v_39]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); break 'yield_0 [v_39]; }, _ => { row[offsets.auxiliaries + 39] = (v_38 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); match v_41.as_canonical_u64() { 1u64 => { let [v_42]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 13] = G::ONE.as_canonical_u64(); break 'yield_0 [v_42]; }, _ => { row[offsets.auxiliaries + 42] = (v_41 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); match v_44.as_canonical_u64() { 1u64 => { let [v_45]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 14] = G::ONE.as_canonical_u64(); break 'yield_0 [v_45]; }, _ => { row[offsets.auxiliaries + 45] = (v_44 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_46]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); match v_47.as_canonical_u64() { 1u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 15] = G::ONE.as_canonical_u64(); break 'yield_0 [v_48]; }, _ => { row[offsets.auxiliaries + 48] = (v_47 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 16] = G::ONE.as_canonical_u64(); break 'yield_0 [v_49]; }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }; row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); match v_50.as_canonical_u64() { 1u64 => { row[offsets.selectors + 17] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 50] = (v_50 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[34])]; row[offsets.auxiliaries + 51] = v_52.as_canonical_u64(); match v_52.as_canonical_u64() { 1u64 => { row[offsets.selectors + 18] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 52] = (v_52 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[35])]; row[offsets.auxiliaries + 53] = v_54.as_canonical_u64(); match v_54.as_canonical_u64() { 1u64 => { row[offsets.selectors + 19] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 54] = (v_54 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 55] = v_56.as_canonical_u64(); match v_56.as_canonical_u64() { 1u64 => { row[offsets.selectors + 20] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 56] = (v_56 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 57] = v_58.as_canonical_u64(); match v_58.as_canonical_u64() { 1u64 => { row[offsets.selectors + 21] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 58] = (v_58 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 59] = v_60.as_canonical_u64(); match v_60.as_canonical_u64() { 1u64 => { row[offsets.selectors + 22] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 60] = (v_60 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 23] = G::ONE.as_canonical_u64(); }, } }, } }, } }, } }, } }, } } + +static SCHEMA_401: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U16], offsets: &[0, 8, 12, 78, 16, 79, 20, 80, 24, 81, 28, 82, 32, 83, 36, 84, 40, 85, 44, 86, 48, 87, 52, 88, 56, 89, 60, 90, 64, 91, 68, 92, 72, 93, 94, 95, 96, 97, 76], bytes: 104 }; + +fn pack_451(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = context.returned::<1>(1)?; seed[4] = v_4.as_canonical_u64(); Ok(()) }, _ => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed[4] = v_5.as_canonical_u64(); Ok(()) }, } } + +fn pack_451_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = context.returned::<1>(1)?; seed.u8(20, v_4); Ok(()) }, _ => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed.u8(20, v_5); Ok(()) }, } } + +fn write_451(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let op_0 = u32_less_than(v_0, v_1); let [v_3]: [G; 1] = [op_0.0]; row[offsets.auxiliaries + 1] = op_0.1[0].as_canonical_u64(); row[offsets.auxiliaries + 2] = op_0.1[1].as_canonical_u64(); row[offsets.auxiliaries + 3] = op_0.1[2].as_canonical_u64(); row[offsets.auxiliaries + 4] = op_0.1[3].as_canonical_u64(); row[offsets.auxiliaries + 5] = op_0.1[4].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_0.1[5].as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 7] = v_4.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 7] = (v_3 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 8] = v_5.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_451: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 16, 20], bytes: 24 }; + +fn pack_457(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 455, &[v_0])?; seed[4] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.call::<1>(1, 455, &[v_1])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [v_3 * v_4]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7, v_8, v_9]: [G; 3] = context.call::<3>(4, 456, &[v_0])?; seed[6] = v_7.as_canonical_u64(); seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); let [v_10, v_11, v_12]: [G; 3] = context.call::<3>(5, 456, &[v_1])?; seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); seed[11] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [v_7 * v_10]; match v_13.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_15]: [G; 1] = context.call::<1>(8, 349, &[v_9, v_12])?; seed[12] = v_15.as_canonical_u64(); match v_15.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_18]: [G; 1] = context.call::<1>(11, 449, &[v_8, v_11, v_2])?; seed[13] = v_18.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn pack_457_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3]: [G; 1] = context.call::<1>(0, 455, &[v_0])?; seed.u8(36, v_3); let [v_4]: [G; 1] = context.call::<1>(1, 455, &[v_1])?; seed.u8(37, v_4); let [v_5]: [G; 1] = [v_3 * v_4]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7, v_8, v_9]: [G; 3] = context.call::<3>(4, 456, &[v_0])?; seed.u8(38, v_7); seed.u32(20, v_8); seed.u32(24, v_9); let [v_10, v_11, v_12]: [G; 3] = context.call::<3>(5, 456, &[v_1])?; seed.u8(39, v_10); seed.u32(28, v_11); seed.u32(32, v_12); let [v_13]: [G; 1] = [v_7 * v_10]; match v_13.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_15]: [G; 1] = context.call::<1>(8, 349, &[v_9, v_12])?; seed.u8(40, v_15); match v_15.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_18]: [G; 1] = context.call::<1>(11, 449, &[v_8, v_11, v_2])?; seed.u8(41, v_18); Ok(()) }, } }, } }, } } + +fn write_457(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [v_3 * v_4]; row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 4] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); let [v_10, v_11, v_12]: [G; 3] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [v_7 * v_10]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_13 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); match v_15.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 14] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, } }, } } + +static SCHEMA_457: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 16, 36, 37, 38, 20, 24, 39, 28, 32, 40, 41], bytes: 48 }; + +fn pack_487(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5]: [G; 2] = context.call::<2>(0, 494, &[v_1])?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 434, &[v_5, v_3])?; seed[7] = v_6.as_canonical_u64(); let [v_9, v_10, v_11]: [G; 3] = context.returned::<3>(4)?; seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } + +fn pack_487_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5]: [G; 2] = context.call::<2>(0, 494, &[v_1])?; seed.u8(52, v_4); seed.u32(44, v_5); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 434, &[v_5, v_3])?; seed.u32(48, v_6); let [v_9, v_10, v_11]: [G; 3] = context.returned::<3>(4)?; seed.u8(53, v_9); seed.full(16, v_10); seed.full(24, v_11); Ok(()) }, _ => { Ok(()) }, } } + +fn write_487(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_4 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_487: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 32, 36, 8, 40, 52, 44, 48, 53, 16, 24], bytes: 56 }; + +fn pack_512(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(0, v_1)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 790, &[v_2])?; seed[8] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_9]: [G; 1] = context.returned::<1>(3)?; seed[9] = v_9.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = context.load::<4>(4, v_0)?; seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = context.call::<1>(5, 790, &[v_2])?; seed[12] = v_14.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.call::<1>(7, 382, &[v_11, v_2, v_15])?; seed[13] = v_16.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = context.store(10, &[v_18, v_5, v_2])?; seed[14] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.returned::<1>(11)?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_21]: [G; 1] = context.call::<1>(12, 790, &[v_2])?; seed[12] = v_21.as_canonical_u64(); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { break 'yield_0 [v_0]; }, _ => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = context.call::<1>(14, 382, &[v_0, v_2, v_22])?; seed[13] = v_23.as_canonical_u64(); break 'yield_0 [v_23]; }, } }; let [v_25]: [G; 1] = context.call::<1>(15, 428, &[v_24, v_3])?; seed[14] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(16, v_25)?; seed[15] = v_26.as_canonical_u64(); seed[16] = v_27.as_canonical_u64(); seed[17] = v_28.as_canonical_u64(); seed[18] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 5u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(20, &[v_31, v_31, v_31])?; seed[19] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.store(21, &[v_30, v_5, v_32])?; seed[20] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = context.returned::<1>(22)?; seed[21] = v_34.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(512, v_26)) }, } }, } }, _ => { Err(no_match(512, v_4)) }, } } + +fn pack_512_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(116, v_4); seed.u32(80, v_5); seed.u32(84, v_6); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 790, &[v_2])?; seed.full(8, v_7); match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_9]: [G; 1] = context.returned::<1>(3)?; seed.full(16, v_9); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = context.load::<4>(4, v_0)?; seed.full(8, v_10); seed.full(16, v_11); seed.u32(88, v_12); seed.full(24, v_13); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = context.call::<1>(5, 790, &[v_2])?; seed.full(32, v_14); let []: [G; 0] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16]: [G; 1] = context.call::<1>(7, 382, &[v_11, v_2, v_15])?; seed.u32(92, v_16); break 'yield_0 []; }, } }; let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = context.store(10, &[v_18, v_5, v_2])?; seed.u32(96, v_19); let [v_20]: [G; 1] = context.returned::<1>(11)?; seed.full(40, v_20); Ok(()) }, _ => { let [v_21]: [G; 1] = context.call::<1>(12, 790, &[v_2])?; seed.full(32, v_21); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { break 'yield_0 [v_0]; }, _ => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = context.call::<1>(14, 382, &[v_0, v_2, v_22])?; seed.u32(92, v_23); break 'yield_0 [v_23]; }, } }; let [v_25]: [G; 1] = context.call::<1>(15, 428, &[v_24, v_3])?; seed.u32(96, v_25); let [v_26, v_27, v_28, v_29]: [G; 4] = context.load::<4>(16, v_25)?; seed.full(40, v_26); seed.u32(100, v_27); seed.u32(104, v_28); seed.full(48, v_29); match v_26.as_canonical_u64() { 5u64 => { let [v_30]: [G; 1] = [G::from_u64(0)]; let [v_31]: [G; 1] = [G::from_u64(1)]; let [v_32]: [G; 1] = context.store(20, &[v_31, v_31, v_31])?; seed.u32(108, v_32); let [v_33]: [G; 1] = context.store(21, &[v_30, v_5, v_32])?; seed.u32(112, v_33); let [v_34]: [G; 1] = context.returned::<1>(22)?; seed.full(56, v_34); Ok(()) }, _ => { Err(no_match(512, v_26)) }, } }, } }, _ => { Err(no_match(512, v_4)) }, } } + +fn write_512(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 5] = (v_7 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_10, v_11, v_12, v_13]: [G; 4] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_13.as_canonical_u64(); match v_10.as_canonical_u64() { 5u64 => { let [v_14]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 8] = v_14.as_canonical_u64(); let [v_17]: [G; 1] = 'yield_0: { match v_14.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_11]; }, _ => { row[offsets.auxiliaries + 9] = (v_14 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_16.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_16]; }, } }; row[offsets.auxiliaries + 11] = v_17.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 12] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 13] = v_20.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 8] = (v_10 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_21.as_canonical_u64(); let [v_24]: [G; 1] = 'yield_0: { match v_21.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_0]; }, _ => { row[offsets.auxiliaries + 10] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_23.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); break 'yield_0 [v_23]; }, } }; row[offsets.auxiliaries + 12] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 13] = v_25.as_canonical_u64(); let [v_26, v_27, v_28, v_29]: [G; 4] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18])]; row[offsets.auxiliaries + 14] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_29.as_canonical_u64(); match v_26.as_canonical_u64() { 5u64 => { let [v_32]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 18] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 19] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 20] = v_34.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(512, v_26)) }, } }, } }, _ => { Err(no_match(512, v_4)) }, } } + +static SCHEMA_512: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 64, 68, 72, 76, 116, 80, 84, 8, 16, 88, 24, 32, 92, 96, 40, 100, 104, 48, 108, 112, 56], bytes: 120 }; + +fn pack_536(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 522, &[])?; seed[2] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 523, &[])?; seed[4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed[5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 524, &[])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed[7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 534, &[])?; seed[8] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed[9] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 533, &[])?; seed[10] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed[11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 535, &[])?; seed[12] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed[13] = v_17.as_canonical_u64(); Ok(()) }, } }, } }, } }, } }, } } + +fn pack_536_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.call::<1>(0, 522, &[])?; seed.u32(12, v_1); let [v_2]: [G; 1] = context.call::<1>(1, 2, &[v_0, v_1])?; seed.u8(36, v_2); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(3, 523, &[])?; seed.u32(16, v_4); let [v_5]: [G; 1] = context.call::<1>(4, 2, &[v_0, v_4])?; seed.u8(37, v_5); match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_7]: [G; 1] = context.call::<1>(6, 524, &[])?; seed.u32(20, v_7); let [v_8]: [G; 1] = context.call::<1>(7, 2, &[v_0, v_7])?; seed.u8(38, v_8); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(9, 534, &[])?; seed.u32(24, v_10); let [v_11]: [G; 1] = context.call::<1>(10, 2, &[v_0, v_10])?; seed.u8(39, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.call::<1>(12, 533, &[])?; seed.u32(28, v_13); let [v_14]: [G; 1] = context.call::<1>(13, 2, &[v_0, v_13])?; seed.u8(40, v_14); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(15, 535, &[])?; seed.u32(32, v_16); let [v_17]: [G; 1] = context.call::<1>(16, 2, &[v_0, v_16])?; seed.u8(41, v_17); Ok(()) }, } }, } }, } }, } }, } } + +fn write_536(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_2 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 6] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 15] = (v_14 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 18] = (v_17 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, } }, } }, } }, } }, } } + +static SCHEMA_536: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 36, 16, 37, 20, 38, 24, 39, 28, 40, 32, 41], bytes: 48 }; + +fn pack_564(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 10] = context.load::<10>(2, v_1)?; seed[13] = v_13.as_canonical_u64(); seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); seed[20] = v_20.as_canonical_u64(); seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_23]: [G; 1] = context.call::<1>(3, 564, &[v_11, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.call::<1>(4, 565, &[v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed[24] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = context.returned::<1>(5)?; seed[25] = v_25.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(564, v_13)) }, } }, _ => { Err(no_match(564, v_2)) }, } } + +fn pack_564_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(112, v_2); seed.u32(40, v_3); seed.u32(44, v_4); seed.u32(48, v_5); seed.u32(52, v_6); seed.u32(56, v_7); seed.u32(60, v_8); seed.u32(64, v_9); seed.u32(68, v_10); seed.u32(72, v_11); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 10] = context.load::<10>(2, v_1)?; seed.u8(113, v_13); seed.u32(76, v_14); seed.u32(80, v_15); seed.u32(84, v_16); seed.u32(88, v_17); seed.u32(92, v_18); seed.u32(96, v_19); seed.u32(100, v_20); seed.u32(104, v_21); seed.u32(108, v_22); match v_13.as_canonical_u64() { 0u64 => { let [v_23]: [G; 1] = context.call::<1>(3, 564, &[v_11, v_22])?; seed.full(8, v_23); let [v_24]: [G; 1] = context.call::<1>(4, 565, &[v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21])?; seed.full(16, v_24); let [v_25]: [G; 1] = context.returned::<1>(5)?; seed.full(24, v_25); Ok(()) }, _ => { Err(no_match(564, v_13)) }, } }, _ => { Err(no_match(564, v_2)) }, } } + +fn write_564(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 10] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_23]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[25])]; row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(564, v_13)) }, } }, _ => { Err(no_match(564, v_2)) }, } } + +static SCHEMA_564: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 32, 36, 112, 40, 44, 48, 52, 56, 60, 64, 68, 72, 113, 76, 80, 84, 88, 92, 96, 100, 104, 108, 8, 16, 24], bytes: 120 }; + +fn pack_572(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let [v_25]: [G; 1] = context.call::<1>(0, 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])?; seed[26] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.call::<1>(1, 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])?; seed[27] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = context.call::<1>(2, 549, &[v_25, v_26])?; seed[28] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_28, v_29]: [G; 2] = context.returned::<2>(3)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); Ok(()) }, _ => { let [v_30, v_31]: [G; 2] = context.returned::<2>(4)?; seed[29] = v_30.as_canonical_u64(); seed[30] = v_31.as_canonical_u64(); Ok(()) }, } } + +fn pack_572_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let [v_25]: [G; 1] = context.call::<1>(0, 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])?; seed.u8(136, v_25); let [v_26]: [G; 1] = context.call::<1>(1, 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])?; seed.u8(137, v_26); let [v_27]: [G; 1] = context.call::<1>(2, 549, &[v_25, v_26])?; seed.u8(138, v_27); match v_27.as_canonical_u64() { 1u64 => { let [v_28, v_29]: [G; 2] = context.returned::<2>(3)?; seed.full(56, v_28); seed.full(64, v_29); Ok(()) }, _ => { let [v_30, v_31]: [G; 2] = context.returned::<2>(4)?; seed.full(56, v_30); seed.full(64, v_31); Ok(()) }, } } + +fn write_572(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let [v_25]: [G; 1] = [G::from_u64(seed[26])]; row[offsets.auxiliaries + 1] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 2] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 3] = v_27.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_28, v_29]: [G; 2] = [G::from_u64(seed[29]), G::from_u64(seed[30])]; row[offsets.auxiliaries + 4] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_29.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 4] = (v_27 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_30, v_31]: [G; 2] = [G::from_u64(seed[29]), G::from_u64(seed[30])]; row[offsets.auxiliaries + 5] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_31.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_572: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 132, 72, 76, 80, 84, 88, 92, 133, 96, 8, 16, 24, 134, 100, 104, 108, 112, 116, 120, 135, 124, 32, 40, 48, 128, 136, 137, 138, 56, 64], bytes: 144 }; + +fn pack_574(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7]: [G; 1] = [v_4 - v_6]; match v_7.as_canonical_u64() { 0u64 => { let [v_8, v_9]: [G; 2] = context.returned::<2>(1)?; seed[8] = v_8.as_canonical_u64(); seed[9] = v_9.as_canonical_u64(); Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(2, 301, &[v_0, v_1, v_6])?; seed[8] = v_10.as_canonical_u64(); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 12] = context.load::<12>(3, v_10)?; seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(4, 301, &[v_2, v_3, v_6])?; seed[21] = v_23.as_canonical_u64(); let [v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 12] = context.load::<12>(5, v_23)?; seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); let [v_36, v_37]: [G; 2] = context.call::<2>(6, 575, &[v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_5])?; seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(1)]; let [v_39]: [G; 1] = [v_6 + v_38]; let [v_40, v_41]: [G; 2] = context.call::<2>(9, 574, &[v_0, v_1, v_2, v_3, v_4, v_5, v_39])?; seed[36] = v_40.as_canonical_u64(); seed[37] = v_41.as_canonical_u64(); let [v_42, v_43]: [G; 2] = context.returned::<2>(10)?; seed[38] = v_42.as_canonical_u64(); seed[39] = v_43.as_canonical_u64(); Ok(()) }, } } + +fn pack_574_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7]: [G; 1] = [v_4 - v_6]; match v_7.as_canonical_u64() { 0u64 => { let [v_8, v_9]: [G; 2] = context.returned::<2>(1)?; seed.u32(188, v_8); seed.u8(238, v_9); Ok(()) }, _ => { let [v_10]: [G; 1] = context.call::<1>(2, 301, &[v_0, v_1, v_6])?; seed.u32(188, v_10); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 12] = context.load::<12>(3, v_10)?; seed.u8(238, v_11); seed.u32(192, v_12); seed.u32(196, v_13); seed.full(40, v_14); seed.full(48, v_15); seed.u32(200, v_16); seed.u32(204, v_17); seed.u32(208, v_18); seed.full(56, v_19); seed.full(64, v_20); seed.full(72, v_21); seed.full(80, v_22); let [v_23]: [G; 1] = context.call::<1>(4, 301, &[v_2, v_3, v_6])?; seed.u32(212, v_23); let [v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 12] = context.load::<12>(5, v_23)?; seed.u8(239, v_24); seed.u32(216, v_25); seed.u32(220, v_26); seed.full(88, v_27); seed.full(96, v_28); seed.u32(224, v_29); seed.u32(228, v_30); seed.u32(232, v_31); seed.full(104, v_32); seed.full(112, v_33); seed.full(120, v_34); seed.full(128, v_35); let [v_36, v_37]: [G; 2] = context.call::<2>(6, 575, &[v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_5])?; seed.full(136, v_36); seed.full(144, v_37); let [v_38]: [G; 1] = [G::from_u64(1)]; let [v_39]: [G; 1] = [v_6 + v_38]; let [v_40, v_41]: [G; 2] = context.call::<2>(9, 574, &[v_0, v_1, v_2, v_3, v_4, v_5, v_39])?; seed.full(152, v_40); seed.full(160, v_41); let [v_42, v_43]: [G; 2] = context.returned::<2>(10)?; seed.full(168, v_42); seed.full(176, v_43); Ok(()) }, } } + +fn write_574(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let [v_7]: [G; 1] = [v_4 - v_6]; match v_7.as_canonical_u64() { 0u64 => { let [v_8, v_9]: [G; 2] = [G::from_u64(seed[8]), G::from_u64(seed[9])]; row[offsets.auxiliaries + 1] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_9.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_7 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 12] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); let [v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 12] = [G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33])]; row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_35.as_canonical_u64(); let [v_36, v_37]: [G; 2] = [G::from_u64(seed[34]), G::from_u64(seed[35])]; row[offsets.auxiliaries + 28] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_37.as_canonical_u64(); let [v_40, v_41]: [G; 2] = [G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 30] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_41.as_canonical_u64(); let [v_42, v_43]: [G; 2] = [G::from_u64(seed[38]), G::from_u64(seed[39])]; row[offsets.auxiliaries + 32] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_43.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_574: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 236, 8, 237, 16, 24, 184, 32, 188, 238, 192, 196, 40, 48, 200, 204, 208, 56, 64, 72, 80, 212, 239, 216, 220, 88, 96, 224, 228, 232, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176], bytes: 240 }; + +fn pack_584(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.call::<1>(1, 790, &[v_0])?; seed[5] = v_5.as_canonical_u64(); let [v_6]: [G; 1] = context.call::<1>(2, 580, &[v_0, v_1, v_2, v_4, v_5])?; seed[6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.call::<1>(3, 585, &[v_0, v_6, v_1])?; seed[7] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.call::<1>(4, 591, &[v_0, v_7])?; seed[8] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_11]: [G; 1] = context.returned::<1>(7)?; seed[9] = v_11.as_canonical_u64(); Ok(()) }, } }, } } + +fn pack_584_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = [G::from_u64(0)]; let [v_5]: [G; 1] = context.call::<1>(1, 790, &[v_0])?; seed.full(24, v_5); let [v_6]: [G; 1] = context.call::<1>(2, 580, &[v_0, v_1, v_2, v_4, v_5])?; seed.u32(44, v_6); let [v_7]: [G; 1] = context.call::<1>(3, 585, &[v_0, v_6, v_1])?; seed.u32(48, v_7); let [v_8]: [G; 1] = context.call::<1>(4, 591, &[v_0, v_7])?; seed.u8(53, v_8); match v_8.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_11]: [G; 1] = context.returned::<1>(7)?; seed.full(32, v_11); Ok(()) }, } }, } } + +fn write_584(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); match v_3.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_3 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); let [v_6]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 6] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_11.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, } } + +static SCHEMA_584: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 40, 8, 52, 16, 24, 44, 48, 53, 32], bytes: 56 }; + +fn pack_590(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(0, v_0)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [G::from_u64(1)]; let [v_10]: [G; 1] = context.store(3, &[v_9, v_9, v_9])?; seed[9] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.store(4, &[v_8, v_4, v_10])?; seed[10] = v_11.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 12] = context.call::<12>(5, 577, &[v_2, v_3])?; seed[9] = v_12.as_canonical_u64(); seed[10] = v_13.as_canonical_u64(); seed[11] = v_14.as_canonical_u64(); seed[12] = v_15.as_canonical_u64(); seed[13] = v_16.as_canonical_u64(); seed[14] = v_17.as_canonical_u64(); seed[15] = v_18.as_canonical_u64(); seed[16] = v_19.as_canonical_u64(); seed[17] = v_20.as_canonical_u64(); seed[18] = v_21.as_canonical_u64(); seed[19] = v_22.as_canonical_u64(); seed[20] = v_23.as_canonical_u64(); let [v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 12] = context.call::<12>(6, 577, &[v_2, v_6])?; seed[21] = v_24.as_canonical_u64(); seed[22] = v_25.as_canonical_u64(); seed[23] = v_26.as_canonical_u64(); seed[24] = v_27.as_canonical_u64(); seed[25] = v_28.as_canonical_u64(); seed[26] = v_29.as_canonical_u64(); seed[27] = v_30.as_canonical_u64(); seed[28] = v_31.as_canonical_u64(); seed[29] = v_32.as_canonical_u64(); seed[30] = v_33.as_canonical_u64(); seed[31] = v_34.as_canonical_u64(); seed[32] = v_35.as_canonical_u64(); let [v_36, v_37]: [G; 2] = context.call::<2>(7, 572, &[v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_1])?; seed[33] = v_36.as_canonical_u64(); seed[34] = v_37.as_canonical_u64(); match v_36.as_canonical_u64() { 1u64 => { let [v_38]: [G; 1] = context.call::<1>(8, 783, &[v_4, v_6])?; seed[35] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.returned::<1>(9)?; seed[36] = v_39.as_canonical_u64(); Ok(()) }, _ => { let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(12, &[v_41, v_41, v_41])?; seed[35] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.store(13, &[v_40, v_6, v_42])?; seed[36] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(14, 590, &[v_7, v_1, v_2, v_6, v_43])?; seed[37] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.store(15, &[v_40, v_4, v_44])?; seed[38] = v_45.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(590, v_5)) }, } } + +fn pack_590_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(188, v_5); seed.full(24, v_6); seed.u32(108, v_7); match v_5.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9]: [G; 1] = [G::from_u64(1)]; let [v_10]: [G; 1] = context.store(3, &[v_9, v_9, v_9])?; seed.u32(112, v_10); let [v_11]: [G; 1] = context.store(4, &[v_8, v_4, v_10])?; seed.u32(116, v_11); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 12] = context.call::<12>(5, 577, &[v_2, v_3])?; seed.u32(112, v_12); seed.u32(116, v_13); seed.u32(120, v_14); seed.u32(124, v_15); seed.u32(128, v_16); seed.u32(132, v_17); seed.u32(136, v_18); seed.u8(189, v_19); seed.u32(140, v_20); seed.full(32, v_21); seed.full(40, v_22); seed.full(48, v_23); let [v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 12] = context.call::<12>(6, 577, &[v_2, v_6])?; seed.u8(190, v_24); seed.u32(144, v_25); seed.u32(148, v_26); seed.u32(152, v_27); seed.u32(156, v_28); seed.u32(160, v_29); seed.u32(164, v_30); seed.u8(191, v_31); seed.u32(168, v_32); seed.full(56, v_33); seed.full(64, v_34); seed.full(72, v_35); let [v_36, v_37]: [G; 2] = context.call::<2>(7, 572, &[v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_1])?; seed.full(80, v_36); seed.full(88, v_37); match v_36.as_canonical_u64() { 1u64 => { let [v_38]: [G; 1] = context.call::<1>(8, 783, &[v_4, v_6])?; seed.u32(172, v_38); let [v_39]: [G; 1] = context.returned::<1>(9)?; seed.u32(176, v_39); Ok(()) }, _ => { let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(12, &[v_41, v_41, v_41])?; seed.u32(172, v_42); let [v_43]: [G; 1] = context.store(13, &[v_40, v_6, v_42])?; seed.u32(176, v_43); let [v_44]: [G; 1] = context.call::<1>(14, 590, &[v_7, v_1, v_2, v_6, v_43])?; seed.u32(180, v_44); let [v_45]: [G; 1] = context.store(15, &[v_40, v_4, v_44])?; seed.u32(184, v_45); Ok(()) }, } }, _ => { Err(no_match(590, v_5)) }, } } + +fn write_590(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 1] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_7.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 5] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 12] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); let [v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 12] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_35.as_canonical_u64(); let [v_36, v_37]: [G; 2] = [G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 28] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_37.as_canonical_u64(); match v_36.as_canonical_u64() { 1u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[35])]; row[offsets.auxiliaries + 30] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 31] = v_39.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 30] = (v_36 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[35])]; row[offsets.auxiliaries + 31] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 32] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 33] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 34] = v_45.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(590, v_5)) }, } } + +static SCHEMA_590: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 96, 100, 8, 16, 104, 188, 24, 108, 112, 116, 120, 124, 128, 132, 136, 189, 140, 32, 40, 48, 190, 144, 148, 152, 156, 160, 164, 191, 168, 56, 64, 72, 80, 88, 172, 176, 180, 184], bytes: 192 }; + +fn pack_608(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 5u64 => { let [v_8]: [G; 1] = context.returned::<1>(3)?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(608, v_2)) }, } }, } } + +fn pack_608_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2, v_3, v_4, v_5]: [G; 4] = context.load::<4>(0, v_0)?; seed.u8(48, v_2); seed.full(16, v_3); seed.u32(44, v_4); seed.full(24, v_5); match v_2.as_canonical_u64() { 5u64 => { let [v_8]: [G; 1] = context.returned::<1>(3)?; seed.full(32, v_8); Ok(()) }, _ => { Err(no_match(608, v_2)) }, } }, } } + +fn write_608(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_2, v_3, v_4, v_5]: [G; 4] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); match v_2.as_canonical_u64() { 5u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(608, v_2)) }, } }, } } + +static SCHEMA_608: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 40, 8, 48, 16, 44, 24, 32], bytes: 56 }; + +fn pack_646(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; match v_0.as_canonical_u64() { 7u64 => { let [v_12]: [G; 1] = [v_3 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_4]; let [v_15]: [G; 1] = context.call::<1>(3, 608, &[v_2, v_14])?; seed[13] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19]: [G; 4] = context.load::<4>(4, v_15)?; seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); match v_16.as_canonical_u64() { 5u64 => { let [v_20, v_21]: [G; 2] = context.call::<2>(5, 125, &[v_17])?; seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); let [v_22, v_23, v_24, v_25]: [G; 4] = context.load::<4>(6, v_20)?; seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); match v_22.as_canonical_u64() { 2u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = context.store(8, &[v_26, v_26, v_26])?; seed[24] = v_27.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(10, &[v_28, v_28, v_28])?; seed[18] = v_29.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_30]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = context.store(12, &[v_30, v_30, v_30])?; seed[13] = v_31.as_canonical_u64(); Ok(()) }, } } + +fn pack_646_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; match v_0.as_canonical_u64() { 7u64 => { let [v_12]: [G; 1] = [v_3 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_4]; let [v_15]: [G; 1] = context.call::<1>(3, 608, &[v_2, v_14])?; seed.u32(140, v_15); let [v_16, v_17, v_18, v_19]: [G; 4] = context.load::<4>(4, v_15)?; seed.u8(160, v_16); seed.u32(144, v_17); seed.full(96, v_18); seed.full(104, v_19); match v_16.as_canonical_u64() { 5u64 => { let [v_20, v_21]: [G; 2] = context.call::<2>(5, 125, &[v_17])?; seed.u32(148, v_20); seed.u32(152, v_21); let [v_22, v_23, v_24, v_25]: [G; 4] = context.load::<4>(6, v_20)?; seed.u8(161, v_22); seed.full(112, v_23); seed.full(120, v_24); seed.full(128, v_25); match v_22.as_canonical_u64() { 2u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = context.store(8, &[v_26, v_26, v_26])?; seed.u32(156, v_27); Ok(()) }, } }, _ => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(10, &[v_28, v_28, v_28])?; seed.u32(148, v_29); Ok(()) }, } }, _ => { let [v_30]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = context.store(12, &[v_30, v_30, v_30])?; seed.u32(140, v_31); Ok(()) }, } } + +fn write_646(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); match v_0.as_canonical_u64() { 7u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19]: [G; 4] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); match v_16.as_canonical_u64() { 5u64 => { let [v_20, v_21]: [G; 2] = [G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 6] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_21.as_canonical_u64(); let [v_22, v_23, v_24, v_25]: [G; 4] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 8] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_25.as_canonical_u64(); match v_22.as_canonical_u64() { 2u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_22 - G::from_u64(2)).inverse().as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 13] = v_27.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 6] = (v_16 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 7] = v_29.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_31.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_646: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 8, 16, 136, 24, 32, 40, 48, 56, 64, 72, 80, 88, 140, 160, 144, 96, 104, 148, 152, 161, 112, 120, 128, 156], bytes: 168 }; + +fn pack_652(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8]: [G; 6] = context.load::<6>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.call::<1>(2, 2, &[v_4, v_1])?; seed[10] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = context.call::<1>(3, 655, &[v_6, v_2])?; seed[11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(5)?; seed[12] = v_13.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_14]: [G; 1] = context.returned::<1>(6)?; seed[11] = v_14.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_15]: [G; 1] = context.returned::<1>(7)?; seed[10] = v_15.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(652, v_3)) }, } } + +fn pack_652_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8]: [G; 6] = context.load::<6>(0, v_0)?; seed.u8(48, v_3); seed.u32(36, v_4); seed.full(8, v_5); seed.u32(40, v_6); seed.full(16, v_7); seed.u32(44, v_8); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.call::<1>(2, 2, &[v_4, v_1])?; seed.u8(49, v_10); match v_10.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = context.call::<1>(3, 655, &[v_6, v_2])?; seed.u8(50, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(5)?; seed.u8(51, v_13); Ok(()) }, } }, _ => { let [v_14]: [G; 1] = context.returned::<1>(6)?; seed.u8(50, v_14); Ok(()) }, } }, _ => { let [v_15]: [G; 1] = context.returned::<1>(7)?; seed.u8(49, v_15); Ok(()) }, } }, _ => { Err(no_match(652, v_3)) }, } } + +fn write_652(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6, v_7, v_8]: [G; 6] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 9] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { row[offsets.auxiliaries + 8] = (v_10 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { row[offsets.auxiliaries + 7] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(652, v_3)) }, } } + +static SCHEMA_652: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 24, 28, 32, 48, 36, 8, 40, 16, 44, 49, 50, 51], bytes: 56 }; + +fn pack_659(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); let [v_53]: [G; 1] = 'yield_0: { match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.call::<1>(2, 658, &[v_4, v_4, v_0, v_51, v_1])?; seed[52] = v_52.as_canonical_u64(); break 'yield_0 [v_52]; }, _ => { break 'yield_0 [v_1]; }, } }, } }; let [v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101]: [G; 48] = context.call::<48>(3, 293, &[v_53])?; seed[53] = v_54.as_canonical_u64(); seed[54] = v_55.as_canonical_u64(); seed[55] = v_56.as_canonical_u64(); seed[56] = v_57.as_canonical_u64(); seed[57] = v_58.as_canonical_u64(); seed[58] = v_59.as_canonical_u64(); seed[59] = v_60.as_canonical_u64(); seed[60] = v_61.as_canonical_u64(); seed[61] = v_62.as_canonical_u64(); seed[62] = v_63.as_canonical_u64(); seed[63] = v_64.as_canonical_u64(); seed[64] = v_65.as_canonical_u64(); seed[65] = v_66.as_canonical_u64(); seed[66] = v_67.as_canonical_u64(); seed[67] = v_68.as_canonical_u64(); seed[68] = v_69.as_canonical_u64(); seed[69] = v_70.as_canonical_u64(); seed[70] = v_71.as_canonical_u64(); seed[71] = v_72.as_canonical_u64(); seed[72] = v_73.as_canonical_u64(); seed[73] = v_74.as_canonical_u64(); seed[74] = v_75.as_canonical_u64(); seed[75] = v_76.as_canonical_u64(); seed[76] = v_77.as_canonical_u64(); seed[77] = v_78.as_canonical_u64(); seed[78] = v_79.as_canonical_u64(); seed[79] = v_80.as_canonical_u64(); seed[80] = v_81.as_canonical_u64(); seed[81] = v_82.as_canonical_u64(); seed[82] = v_83.as_canonical_u64(); seed[83] = v_84.as_canonical_u64(); seed[84] = v_85.as_canonical_u64(); seed[85] = v_86.as_canonical_u64(); seed[86] = v_87.as_canonical_u64(); seed[87] = v_88.as_canonical_u64(); seed[88] = v_89.as_canonical_u64(); seed[89] = v_90.as_canonical_u64(); seed[90] = v_91.as_canonical_u64(); seed[91] = v_92.as_canonical_u64(); seed[92] = v_93.as_canonical_u64(); seed[93] = v_94.as_canonical_u64(); seed[94] = v_95.as_canonical_u64(); seed[95] = v_96.as_canonical_u64(); seed[96] = v_97.as_canonical_u64(); seed[97] = v_98.as_canonical_u64(); seed[98] = v_99.as_canonical_u64(); seed[99] = v_100.as_canonical_u64(); seed[100] = v_101.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_54.as_canonical_u64() { _ => { match v_54.as_canonical_u64() { 8u64 => { let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.call::<1>(5, 651, &[v_55, v_55, v_53, v_2, v_102])?; seed[101] = v_103.as_canonical_u64(); break 'yield_0 []; }, _ => { let [v_104]: [G; 1] = context.call::<1>(6, 298, &[v_53])?; seed[101] = v_104.as_canonical_u64(); let [v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116]: [G; 12] = context.load::<12>(7, v_104)?; seed[102] = v_105.as_canonical_u64(); seed[103] = v_106.as_canonical_u64(); seed[104] = v_107.as_canonical_u64(); seed[105] = v_108.as_canonical_u64(); seed[106] = v_109.as_canonical_u64(); seed[107] = v_110.as_canonical_u64(); seed[108] = v_111.as_canonical_u64(); seed[109] = v_112.as_canonical_u64(); seed[110] = v_113.as_canonical_u64(); seed[111] = v_114.as_canonical_u64(); seed[112] = v_115.as_canonical_u64(); seed[113] = v_116.as_canonical_u64(); match v_105.as_canonical_u64() { 5u64 => { let [v_117]: [G; 1] = [G::from_u64(0)]; let [v_118]: [G; 1] = context.call::<1>(9, 649, &[v_2, v_106, v_117])?; seed[114] = v_118.as_canonical_u64(); let [v_119]: [G; 1] = [G::from_u64(1)]; let [v_120]: [G; 1] = context.store(11, &[v_119, v_119, v_119])?; seed[115] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = context.store(12, &[v_119, v_119, v_119, v_119, v_119, v_119])?; seed[116] = v_121.as_canonical_u64(); let [v_122]: [G; 1] = context.store(13, &[v_117, v_53, v_117, v_120, v_118, v_121])?; seed[117] = v_122.as_canonical_u64(); break 'yield_0 []; }, _ => { let [v_123]: [G; 1] = [G::from_u64(1)]; let [v_124]: [G; 1] = context.store(15, &[v_123, v_123, v_123, v_123, v_123, v_123])?; seed[114] = v_124.as_canonical_u64(); break 'yield_0 []; }, } }, } }, } }; let [v_126]: [G; 1] = context.call::<1>(16, 643, &[v_0])?; seed[118] = v_126.as_canonical_u64(); match v_126.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_127]: [G; 1] = context.returned::<1>(17)?; seed[119] = v_127.as_canonical_u64(); Ok(()) }, } } + +fn pack_659_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed.u8(402, v_3); seed.u32(328, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(403, v_8); seed.u8(404, v_9); seed.u8(405, v_10); seed.u8(406, v_11); seed.full(40, v_12); seed.full(48, v_13); seed.full(56, v_14); seed.full(64, v_15); seed.u8(407, v_16); seed.u8(408, v_17); seed.u8(409, v_18); seed.u8(410, v_19); seed.u32(332, v_20); seed.u8(411, v_21); seed.full(72, v_22); seed.full(80, v_23); seed.u8(412, v_24); seed.u8(413, v_25); seed.u8(414, v_26); seed.u8(415, v_27); seed.u8(416, v_28); seed.u8(417, v_29); seed.full(88, v_30); seed.full(96, v_31); seed.u8(418, v_32); seed.u8(419, v_33); seed.u8(420, v_34); seed.u8(421, v_35); seed.u8(422, v_36); seed.u8(423, v_37); seed.full(104, v_38); seed.full(112, v_39); seed.u8(424, v_40); seed.u8(425, v_41); seed.u8(426, v_42); seed.u8(427, v_43); seed.u8(428, v_44); seed.u8(429, v_45); seed.full(120, v_46); seed.u32(336, v_47); seed.u32(340, v_48); seed.u32(344, v_49); seed.u32(348, v_50); let [v_53]: [G; 1] = 'yield_0: { match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.call::<1>(2, 658, &[v_4, v_4, v_0, v_51, v_1])?; seed.u8(430, v_52); break 'yield_0 [v_52]; }, _ => { break 'yield_0 [v_1]; }, } }, } }; let [v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101]: [G; 48] = context.call::<48>(3, 293, &[v_53])?; seed.u8(431, v_54); seed.u32(352, v_55); seed.full(128, v_56); seed.full(136, v_57); seed.full(144, v_58); seed.u8(432, v_59); seed.u8(433, v_60); seed.u8(434, v_61); seed.u8(435, v_62); seed.full(152, v_63); seed.full(160, v_64); seed.full(168, v_65); seed.full(176, v_66); seed.u8(436, v_67); seed.u8(437, v_68); seed.u8(438, v_69); seed.u8(439, v_70); seed.u32(356, v_71); seed.u8(440, v_72); seed.full(184, v_73); seed.full(192, v_74); seed.u8(441, v_75); seed.u8(442, v_76); seed.u8(443, v_77); seed.u8(444, v_78); seed.u8(445, v_79); seed.u8(446, v_80); seed.full(200, v_81); seed.full(208, v_82); seed.u8(447, v_83); seed.u8(448, v_84); seed.u8(449, v_85); seed.u8(450, v_86); seed.u8(451, v_87); seed.u8(452, v_88); seed.full(216, v_89); seed.full(224, v_90); seed.u8(453, v_91); seed.u8(454, v_92); seed.u8(455, v_93); seed.u8(456, v_94); seed.u8(457, v_95); seed.u8(458, v_96); seed.full(232, v_97); seed.u32(360, v_98); seed.u32(364, v_99); seed.u32(368, v_100); seed.u32(372, v_101); let []: [G; 0] = 'yield_0: { match v_54.as_canonical_u64() { _ => { match v_54.as_canonical_u64() { 8u64 => { let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.call::<1>(5, 651, &[v_55, v_55, v_53, v_2, v_102])?; seed.u32(376, v_103); break 'yield_0 []; }, _ => { let [v_104]: [G; 1] = context.call::<1>(6, 298, &[v_53])?; seed.u32(376, v_104); let [v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116]: [G; 12] = context.load::<12>(7, v_104)?; seed.u8(459, v_105); seed.full(240, v_106); seed.u32(380, v_107); seed.full(248, v_108); seed.full(256, v_109); seed.full(264, v_110); seed.full(272, v_111); seed.full(280, v_112); seed.full(288, v_113); seed.full(296, v_114); seed.full(304, v_115); seed.full(312, v_116); match v_105.as_canonical_u64() { 5u64 => { let [v_117]: [G; 1] = [G::from_u64(0)]; let [v_118]: [G; 1] = context.call::<1>(9, 649, &[v_2, v_106, v_117])?; seed.u32(384, v_118); let [v_119]: [G; 1] = [G::from_u64(1)]; let [v_120]: [G; 1] = context.store(11, &[v_119, v_119, v_119])?; seed.u32(388, v_120); let [v_121]: [G; 1] = context.store(12, &[v_119, v_119, v_119, v_119, v_119, v_119])?; seed.u32(392, v_121); let [v_122]: [G; 1] = context.store(13, &[v_117, v_53, v_117, v_120, v_118, v_121])?; seed.u32(396, v_122); break 'yield_0 []; }, _ => { let [v_123]: [G; 1] = [G::from_u64(1)]; let [v_124]: [G; 1] = context.store(15, &[v_123, v_123, v_123, v_123, v_123, v_123])?; seed.u32(384, v_124); break 'yield_0 []; }, } }, } }, } }; let [v_126]: [G; 1] = context.call::<1>(16, 643, &[v_0])?; seed.u8(460, v_126); match v_126.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_127]: [G; 1] = context.returned::<1>(17)?; seed.full(320, v_127); Ok(()) }, } } + +fn write_659(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 48] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); let [v_53]: [G; 1] = 'yield_0: { match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_52]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_52.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_52]; }, _ => { row[offsets.auxiliaries + 49] = (v_3 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_1]; }, } }, } }; row[offsets.auxiliaries + 50] = v_53.as_canonical_u64(); let [v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101]: [G; 48] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100])]; row[offsets.auxiliaries + 51] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_101.as_canonical_u64(); let [v_125]: [G; 1] = 'yield_0: { match v_54.as_canonical_u64() { _ => { match v_54.as_canonical_u64() { 8u64 => { let [v_103]: [G; 1] = [G::from_u64(seed[101])]; row[offsets.auxiliaries + 99] = v_103.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_103]; }, _ => { row[offsets.auxiliaries + 99] = (v_54 - G::from_u64(8)).inverse().as_canonical_u64(); let [v_104]: [G; 1] = [G::from_u64(seed[101])]; row[offsets.auxiliaries + 100] = v_104.as_canonical_u64(); let [v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116]: [G; 12] = [G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113])]; row[offsets.auxiliaries + 101] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_116.as_canonical_u64(); match v_105.as_canonical_u64() { 5u64 => { let [v_118]: [G; 1] = [G::from_u64(seed[114])]; row[offsets.auxiliaries + 113] = v_118.as_canonical_u64(); let [v_120]: [G; 1] = [G::from_u64(seed[115])]; row[offsets.auxiliaries + 114] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = [G::from_u64(seed[116])]; row[offsets.auxiliaries + 115] = v_121.as_canonical_u64(); let [v_122]: [G; 1] = [G::from_u64(seed[117])]; row[offsets.auxiliaries + 116] = v_122.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_122]; }, _ => { row[offsets.auxiliaries + 113] = (v_105 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_124]: [G; 1] = [G::from_u64(seed[114])]; row[offsets.auxiliaries + 114] = v_124.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 [v_124]; }, } }, } }, } }; row[offsets.auxiliaries + 117] = v_125.as_canonical_u64(); let [v_126]: [G; 1] = [G::from_u64(seed[118])]; row[offsets.auxiliaries + 118] = v_126.as_canonical_u64(); match v_126.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 119] = (v_126 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_127]: [G; 1] = [G::from_u64(seed[119])]; row[offsets.auxiliaries + 120] = v_127.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_659: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 400, 401, 8, 402, 328, 16, 24, 32, 403, 404, 405, 406, 40, 48, 56, 64, 407, 408, 409, 410, 332, 411, 72, 80, 412, 413, 414, 415, 416, 417, 88, 96, 418, 419, 420, 421, 422, 423, 104, 112, 424, 425, 426, 427, 428, 429, 120, 336, 340, 344, 348, 430, 431, 352, 128, 136, 144, 432, 433, 434, 435, 152, 160, 168, 176, 436, 437, 438, 439, 356, 440, 184, 192, 441, 442, 443, 444, 445, 446, 200, 208, 447, 448, 449, 450, 451, 452, 216, 224, 453, 454, 455, 456, 457, 458, 232, 360, 364, 368, 372, 376, 459, 240, 380, 248, 256, 264, 272, 280, 288, 296, 304, 312, 384, 388, 392, 396, 460, 320], bytes: 464 }; + +fn pack_660(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_4.as_canonical_u64() { _ => { match v_4.as_canonical_u64() { 8u64 => { let [v_53]: [G; 1] = context.returned::<1>(2)?; seed[53] = v_53.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, } } + +fn pack_660_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed.u8(169, v_4); seed.u32(144, v_5); seed.full(16, v_6); seed.full(24, v_7); seed.full(32, v_8); seed.u8(170, v_9); seed.u8(171, v_10); seed.u8(172, v_11); seed.u8(173, v_12); seed.full(40, v_13); seed.full(48, v_14); seed.full(56, v_15); seed.full(64, v_16); seed.u8(174, v_17); seed.u8(175, v_18); seed.u8(176, v_19); seed.u8(177, v_20); seed.u32(148, v_21); seed.u8(178, v_22); seed.full(72, v_23); seed.full(80, v_24); seed.u8(179, v_25); seed.u8(180, v_26); seed.u8(181, v_27); seed.u8(182, v_28); seed.u8(183, v_29); seed.u8(184, v_30); seed.full(88, v_31); seed.full(96, v_32); seed.u8(185, v_33); seed.u8(186, v_34); seed.u8(187, v_35); seed.u8(188, v_36); seed.u8(189, v_37); seed.u8(190, v_38); seed.full(104, v_39); seed.full(112, v_40); seed.u8(191, v_41); seed.u8(192, v_42); seed.u8(193, v_43); seed.u8(194, v_44); seed.u8(195, v_45); seed.u8(196, v_46); seed.full(120, v_47); seed.u32(152, v_48); seed.u32(156, v_49); seed.u32(160, v_50); seed.u32(164, v_51); match v_4.as_canonical_u64() { _ => { match v_4.as_canonical_u64() { 8u64 => { let [v_53]: [G; 1] = context.returned::<1>(2)?; seed.full(128, v_53); Ok(()) }, _ => { Ok(()) }, } }, } } + +fn write_660(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 48] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_51.as_canonical_u64(); match v_4.as_canonical_u64() { _ => { match v_4.as_canonical_u64() { 8u64 => { let [v_53]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 49] = v_53.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 49] = (v_4 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, } } + +static SCHEMA_660: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 168, 136, 8, 140, 169, 144, 16, 24, 32, 170, 171, 172, 173, 40, 48, 56, 64, 174, 175, 176, 177, 148, 178, 72, 80, 179, 180, 181, 182, 183, 184, 88, 96, 185, 186, 187, 188, 189, 190, 104, 112, 191, 192, 193, 194, 195, 196, 120, 152, 156, 160, 164, 128], bytes: 200 }; + +fn pack_711(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_1)?; seed[7] = v_7.as_canonical_u64(); seed[8] = v_8.as_canonical_u64(); seed[9] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.call::<1>(5, 369, &[v_4, v_2, v_11])?; seed[10] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = context.call::<1>(6, 653, &[v_12, v_8])?; seed[11] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { let [v_14]: [G; 1] = context.returned::<1>(7)?; seed[12] = v_14.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(711, v_7)) }, } }, _ => { Err(no_match(711, v_3)) }, } } + +fn pack_711_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(52, v_3); seed.u32(32, v_4); seed.u32(36, v_5); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_1)?; seed.u8(53, v_7); seed.u32(40, v_8); seed.u32(44, v_9); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.call::<1>(5, 369, &[v_4, v_2, v_11])?; seed.u32(48, v_12); let [v_13]: [G; 1] = context.call::<1>(6, 653, &[v_12, v_8])?; seed.full(16, v_13); match v_13.as_canonical_u64() { 1u64 => { let [v_14]: [G; 1] = context.returned::<1>(7)?; seed.u8(54, v_14); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(711, v_7)) }, } }, _ => { Err(no_match(711, v_3)) }, } } + +fn write_711(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { let [v_14]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 9] = (v_13 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(711, v_7)) }, } }, _ => { Err(no_match(711, v_3)) }, } } + +static SCHEMA_711: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 24, 28, 8, 52, 32, 36, 53, 40, 44, 48, 16, 54], bytes: 56 }; + +fn pack_719(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13]: [G; 1] = context.call::<1>(0, 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])?; seed[14] = v_13.as_canonical_u64(); match v_0.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(4, &[v_15, v_15, v_15])?; seed[15] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = context.call::<1>(5, 520, &[v_2, v_16])?; seed[16] = v_17.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(11, &[v_19, v_19, v_19])?; seed[15] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(12, 520, &[v_2, v_20])?; seed[16] = v_21.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(20, &[v_23, v_23, v_23])?; seed[15] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = context.call::<1>(21, 520, &[v_2, v_24])?; seed[16] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.store(22, &[v_22, v_22, v_22])?; seed[17] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = context.call::<1>(23, 335, &[v_25, v_26])?; seed[18] = v_27.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_30]: [G; 1] = context.store(32, &[v_29, v_29, v_29])?; seed[15] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(33, 520, &[v_2, v_30])?; seed[16] = v_31.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = context.store(40, &[v_33, v_33, v_33])?; seed[15] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.call::<1>(41, 520, &[v_2, v_34])?; seed[16] = v_35.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_37]: [G; 1] = [G::from_u64(1)]; let [v_38]: [G; 1] = context.store(47, &[v_37, v_37, v_37])?; seed[15] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.call::<1>(48, 520, &[v_2, v_38])?; seed[16] = v_39.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(56, &[v_41, v_41, v_41])?; seed[15] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(57, 520, &[v_2, v_42])?; seed[16] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(59, 300, &[v_3, v_4])?; seed[17] = v_44.as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = context.load::<12>(60, v_44)?; seed[18] = v_45.as_canonical_u64(); seed[19] = v_46.as_canonical_u64(); seed[20] = v_47.as_canonical_u64(); seed[21] = v_48.as_canonical_u64(); seed[22] = v_49.as_canonical_u64(); seed[23] = v_50.as_canonical_u64(); seed[24] = v_51.as_canonical_u64(); seed[25] = v_52.as_canonical_u64(); seed[26] = v_53.as_canonical_u64(); seed[27] = v_54.as_canonical_u64(); seed[28] = v_55.as_canonical_u64(); seed[29] = v_56.as_canonical_u64(); match v_45.as_canonical_u64() { 5u64 => { let [v_57]: [G; 1] = [v_48 + v_49]; let [v_58]: [G; 1] = [G::from_u64(1)]; let [v_59]: [G; 1] = context.store(66, &[v_58, v_58, v_58])?; seed[30] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(67, 615, &[v_47, v_57, v_59])?; seed[31] = v_60.as_canonical_u64(); match v_51.as_canonical_u64() { 0u64 => { let [v_61]: [G; 1] = [G::from_u64(1)]; let [v_62]: [G; 1] = context.store(70, &[v_61, v_61, v_61])?; seed[32] = v_62.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(719, v_45)) }, } }, 7u64 => { let [v_64]: [G; 1] = [G::from_u64(1)]; let [v_65]: [G; 1] = context.store(75, &[v_64, v_64, v_64])?; seed[15] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(76, 520, &[v_2, v_65])?; seed[16] = v_66.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(719, v_0)) }, } } + +fn pack_719_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13]: [G; 1] = context.call::<1>(0, 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])?; seed.full(48, v_13); match v_0.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(4, &[v_15, v_15, v_15])?; seed.u32(152, v_16); let [v_17]: [G; 1] = context.call::<1>(5, 520, &[v_2, v_16])?; seed.full(56, v_17); Ok(()) }, 1u64 => { let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(11, &[v_19, v_19, v_19])?; seed.u32(152, v_20); let [v_21]: [G; 1] = context.call::<1>(12, 520, &[v_2, v_20])?; seed.full(56, v_21); Ok(()) }, 2u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = context.store(20, &[v_23, v_23, v_23])?; seed.u32(152, v_24); let [v_25]: [G; 1] = context.call::<1>(21, 520, &[v_2, v_24])?; seed.full(56, v_25); let [v_26]: [G; 1] = context.store(22, &[v_22, v_22, v_22])?; seed.u32(156, v_26); let [v_27]: [G; 1] = context.call::<1>(23, 335, &[v_25, v_26])?; seed.u8(182, v_27); Ok(()) }, 3u64 => { let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_30]: [G; 1] = context.store(32, &[v_29, v_29, v_29])?; seed.u32(152, v_30); let [v_31]: [G; 1] = context.call::<1>(33, 520, &[v_2, v_30])?; seed.full(56, v_31); Ok(()) }, 4u64 => { let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = context.store(40, &[v_33, v_33, v_33])?; seed.u32(152, v_34); let [v_35]: [G; 1] = context.call::<1>(41, 520, &[v_2, v_34])?; seed.full(56, v_35); Ok(()) }, 5u64 => { let [v_37]: [G; 1] = [G::from_u64(1)]; let [v_38]: [G; 1] = context.store(47, &[v_37, v_37, v_37])?; seed.u32(152, v_38); let [v_39]: [G; 1] = context.call::<1>(48, 520, &[v_2, v_38])?; seed.full(56, v_39); Ok(()) }, 6u64 => { let [v_41]: [G; 1] = [G::from_u64(1)]; let [v_42]: [G; 1] = context.store(56, &[v_41, v_41, v_41])?; seed.u32(152, v_42); let [v_43]: [G; 1] = context.call::<1>(57, 520, &[v_2, v_42])?; seed.full(56, v_43); let [v_44]: [G; 1] = context.call::<1>(59, 300, &[v_3, v_4])?; seed.u32(156, v_44); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = context.load::<12>(60, v_44)?; seed.u8(182, v_45); seed.full(64, v_46); seed.u32(160, v_47); seed.full(72, v_48); seed.full(80, v_49); seed.full(88, v_50); seed.full(96, v_51); seed.full(104, v_52); seed.full(112, v_53); seed.full(120, v_54); seed.full(128, v_55); seed.full(136, v_56); match v_45.as_canonical_u64() { 5u64 => { let [v_57]: [G; 1] = [v_48 + v_49]; let [v_58]: [G; 1] = [G::from_u64(1)]; let [v_59]: [G; 1] = context.store(66, &[v_58, v_58, v_58])?; seed.u32(164, v_59); let [v_60]: [G; 1] = context.call::<1>(67, 615, &[v_47, v_57, v_59])?; seed.u32(168, v_60); match v_51.as_canonical_u64() { 0u64 => { let [v_61]: [G; 1] = [G::from_u64(1)]; let [v_62]: [G; 1] = context.store(70, &[v_61, v_61, v_61])?; seed.u32(172, v_62); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(719, v_45)) }, } }, 7u64 => { let [v_64]: [G; 1] = [G::from_u64(1)]; let [v_65]: [G; 1] = context.store(75, &[v_64, v_64, v_64])?; seed.u32(152, v_65); let [v_66]: [G; 1] = context.call::<1>(76, 520, &[v_2, v_65])?; seed.full(56, v_66); Ok(()) }, _ => { Err(no_match(719, v_0)) }, } } + +fn write_719(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let [v_13]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 1] = v_13.as_canonical_u64(); match v_0.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_24]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_24.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 4] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 5] = v_27.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_30]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_31.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_34]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_35.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_39.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_42]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 4] = v_44.as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 12] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29])]; row[offsets.auxiliaries + 5] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_56.as_canonical_u64(); match v_45.as_canonical_u64() { 5u64 => { let [v_59]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 17] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 18] = v_60.as_canonical_u64(); match v_51.as_canonical_u64() { 0u64 => { let [v_62]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 19] = v_62.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 19] = (v_51 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(719, v_45)) }, } }, 7u64 => { let [v_65]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 2] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 3] = v_66.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(719, v_0)) }, } } + +static SCHEMA_719: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 176, 177, 144, 178, 8, 16, 24, 179, 180, 32, 181, 40, 148, 48, 152, 56, 156, 182, 64, 160, 72, 80, 88, 96, 104, 112, 120, 128, 136, 164, 168, 172], bytes: 184 }; + +fn pack_727(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_8]: [G; 1] = context.returned::<1>(4)?; seed[6] = v_8.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(727, v_2)) }, } } + +fn pack_727_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_2); seed.full(16, v_3); seed.u32(28, v_4); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_8]: [G; 1] = context.returned::<1>(4)?; seed.u8(33, v_8); Ok(()) }, } }, _ => { Err(no_match(727, v_2)) }, } } + +fn write_727(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [v_3 - v_1]; match v_6.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 4] = (v_6 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(727, v_2)) }, } } + +static SCHEMA_727: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 24, 8, 32, 16, 28, 33], bytes: 40 }; + +fn pack_728(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_1.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 8u64 => { break 'yield_0 []; }, 7u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 6u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 4u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 5u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_50]: [G; 1] = context.call::<1>(12, 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])?; seed[50] = v_50.as_canonical_u64(); Ok(()) }, } } + +fn pack_728_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 48] = context.call::<48>(0, 293, &[v_0])?; seed.u8(121, v_1); seed.u32(80, v_2); seed.full(8, v_3); seed.full(16, v_4); seed.full(24, v_5); seed.u8(122, v_6); seed.u8(123, v_7); seed.u8(124, v_8); seed.u8(125, v_9); seed.u8(126, v_10); seed.u32(84, v_11); seed.u32(88, v_12); seed.u32(92, v_13); seed.u8(127, v_14); seed.u8(128, v_15); seed.u8(129, v_16); seed.u8(130, v_17); seed.u8(131, v_18); seed.u8(132, v_19); seed.full(32, v_20); seed.full(40, v_21); seed.u8(133, v_22); seed.u8(134, v_23); seed.u8(135, v_24); seed.u8(136, v_25); seed.u8(137, v_26); seed.u8(138, v_27); seed.full(48, v_28); seed.full(56, v_29); seed.u8(139, v_30); seed.u8(140, v_31); seed.u8(141, v_32); seed.u8(142, v_33); seed.u8(143, v_34); seed.u8(144, v_35); seed.full(64, v_36); seed.full(72, v_37); seed.u8(145, v_38); seed.u8(146, v_39); seed.u8(147, v_40); seed.u8(148, v_41); seed.u8(149, v_42); seed.u8(150, v_43); seed.u32(96, v_44); seed.u32(100, v_45); seed.u32(104, v_46); seed.u32(108, v_47); seed.u32(112, v_48); match v_1.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 8u64 => { break 'yield_0 []; }, 7u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 6u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 4u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 5u64 => { match v_2.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_50]: [G; 1] = context.call::<1>(12, 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])?; seed.u32(116, v_50); Ok(()) }, } } + +fn write_728(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48]: [G; 48] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_48.as_canonical_u64(); match v_1.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 8u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, 7u64 => { match v_2.as_canonical_u64() { _ => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, 6u64 => { match v_2.as_canonical_u64() { _ => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, 4u64 => { match v_2.as_canonical_u64() { _ => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, 5u64 => { match v_2.as_canonical_u64() { _ => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, _ => { row[offsets.auxiliaries + 49] = (v_1 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 50] = (v_1 - G::from_u64(7)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 51] = (v_1 - G::from_u64(6)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 52] = (v_1 - G::from_u64(4)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 53] = (v_1 - G::from_u64(5)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_50]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 54] = v_50.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_728: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 120, 121, 80, 8, 16, 24, 122, 123, 124, 125, 126, 84, 88, 92, 127, 128, 129, 130, 131, 132, 32, 40, 133, 134, 135, 136, 137, 138, 48, 56, 139, 140, 141, 142, 143, 144, 64, 72, 145, 146, 147, 148, 149, 150, 96, 100, 104, 108, 112, 116], bytes: 152 }; + +fn pack_729(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 727, &[v_1, v_2])?; seed[7] = v_6.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(729, v_3)) }, } } + +fn pack_729_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(28, v_3); seed.u8(29, v_4); seed.u32(24, v_5); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_6]: [G; 1] = context.call::<1>(1, 727, &[v_1, v_2])?; seed.u8(30, v_6); Ok(()) }, _ => { Err(no_match(729, v_3)) }, } } + +fn write_729(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_6.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, _ => { row[offsets.auxiliaries + 5] = (v_6 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(729, v_3)) }, } } + +static SCHEMA_729: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 16, 20, 8, 28, 29, 24, 30], bytes: 32 }; + +fn pack_736(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.call::<6>(2, 804, &[v_8, v_10, v_1, v_2, v_3, v_4, v_5, v_6])?; seed[11] = v_11.as_canonical_u64(); seed[12] = v_12.as_canonical_u64(); seed[13] = v_13.as_canonical_u64(); seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.returned::<6>(3)?; seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); seed[20] = v_20.as_canonical_u64(); seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(736, v_7)) }, } } + +fn pack_736_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(117, v_7); seed.u32(96, v_8); seed.u32(100, v_9); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.call::<6>(2, 804, &[v_8, v_10, v_1, v_2, v_3, v_4, v_5, v_6])?; seed.u8(118, v_11); seed.u8(119, v_12); seed.u32(104, v_13); seed.full(24, v_14); seed.u32(108, v_15); seed.u32(112, v_16); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.returned::<6>(3)?; seed.full(32, v_17); seed.full(40, v_18); seed.full(48, v_19); seed.full(56, v_20); seed.full(64, v_21); seed.full(72, v_22); Ok(()) }, _ => { Err(no_match(736, v_7)) }, } } + +fn write_736(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16])]; row[offsets.auxiliaries + 4] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_16.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 10] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_22.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(736, v_7)) }, } } + +static SCHEMA_736: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 80, 116, 8, 84, 16, 88, 92, 117, 96, 100, 118, 119, 104, 24, 108, 112, 32, 40, 48, 56, 64, 72], bytes: 120 }; + +fn pack_739(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(0, v_0)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_19]: [G; 1] = context.call::<1>(1, 727, &[v_1, v_2])?; seed[20] = v_19.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(739, v_16)) }, } } + +fn pack_739_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(94, v_16); seed.u8(95, v_17); seed.u32(88, v_18); match v_16.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_19]: [G; 1] = context.call::<1>(1, 727, &[v_1, v_2])?; seed.u8(96, v_19); Ok(()) }, _ => { Err(no_match(739, v_16)) }, } } + +fn write_739(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_16, v_17, v_18]: [G; 3] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_19]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_19.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, _ => { row[offsets.auxiliaries + 5] = (v_19 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(739, v_16)) }, } } + +static SCHEMA_739: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 56, 60, 8, 92, 16, 64, 24, 68, 72, 93, 32, 76, 40, 80, 84, 48, 94, 95, 88, 96], bytes: 104 }; + +fn pack_740(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(0, v_0)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); Ok(()) } + +fn pack_740_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(74, v_13); seed.u8(75, v_14); seed.u32(68, v_15); Ok(()) } + +fn write_740(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16])]; row[offsets.auxiliaries + 1] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(740, v_13)) }, } } + +static SCHEMA_740: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 40, 72, 8, 44, 16, 48, 52, 73, 24, 56, 32, 60, 64, 74, 75, 68], bytes: 80 }; + +fn pack_752(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 6, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[10] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, _ => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29]: [G; 18] = context.call::<18>(3, 119, &[v_0])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); seed[13] = v_14.as_canonical_u64(); seed[14] = v_15.as_canonical_u64(); seed[15] = v_16.as_canonical_u64(); seed[16] = v_17.as_canonical_u64(); seed[17] = v_18.as_canonical_u64(); seed[18] = v_19.as_canonical_u64(); seed[19] = v_20.as_canonical_u64(); seed[20] = v_21.as_canonical_u64(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); seed[23] = v_24.as_canonical_u64(); seed[24] = v_25.as_canonical_u64(); seed[25] = v_26.as_canonical_u64(); seed[26] = v_27.as_canonical_u64(); seed[27] = v_28.as_canonical_u64(); seed[28] = v_29.as_canonical_u64(); let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 8] = context.call::<8>(4, 17, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[29] = v_30.as_canonical_u64(); seed[30] = v_31.as_canonical_u64(); seed[31] = v_32.as_canonical_u64(); seed[32] = v_33.as_canonical_u64(); seed[33] = v_34.as_canonical_u64(); seed[34] = v_35.as_canonical_u64(); seed[35] = v_36.as_canonical_u64(); seed[36] = v_37.as_canonical_u64(); let [v_38, v_39]: [G; 2] = context.call::<2>(5, 752, &[v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37])?; seed[37] = v_38.as_canonical_u64(); seed[38] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.store(7, &[v_40, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_38])?; seed[39] = v_41.as_canonical_u64(); Ok(()) }, } } + +fn pack_752_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let [v_9]: [G; 1] = context.call::<1>(0, 6, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(196, v_9); match v_9.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = context.store(2, &[v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10])?; seed.full(72, v_11); Ok(()) }, _ => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29]: [G; 18] = context.call::<18>(3, 119, &[v_0])?; seed.full(72, v_12); seed.full(80, v_13); seed.u8(197, v_14); seed.u8(198, v_15); seed.u8(199, v_16); seed.u8(200, v_17); seed.u8(201, v_18); seed.u8(202, v_19); seed.full(88, v_20); seed.full(96, v_21); seed.u8(203, v_22); seed.u8(204, v_23); seed.u8(205, v_24); seed.u8(206, v_25); seed.u8(207, v_26); seed.u8(208, v_27); seed.u32(180, v_28); seed.u32(184, v_29); let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 8] = context.call::<8>(4, 17, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.full(104, v_30); seed.full(112, v_31); seed.full(120, v_32); seed.full(128, v_33); seed.full(136, v_34); seed.full(144, v_35); seed.full(152, v_36); seed.full(160, v_37); let [v_38, v_39]: [G; 2] = context.call::<2>(5, 752, &[v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37])?; seed.u32(188, v_38); seed.full(168, v_39); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.store(7, &[v_40, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_38])?; seed.u32(192, v_41); Ok(()) }, } } + +fn write_752(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let [v_9]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); match v_9.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 2] = (v_9 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29]: [G; 18] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_29.as_canonical_u64(); let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 8] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36])]; row[offsets.auxiliaries + 21] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_37.as_canonical_u64(); let [v_38, v_39]: [G; 2] = [G::from_u64(seed[37]), G::from_u64(seed[38])]; row[offsets.auxiliaries + 29] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_39.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 31] = v_41.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_752: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 176, 8, 16, 24, 32, 40, 48, 56, 64, 196, 72, 80, 197, 198, 199, 200, 201, 202, 88, 96, 203, 204, 205, 206, 207, 208, 180, 184, 104, 112, 120, 128, 136, 144, 152, 160, 188, 168, 192], bytes: 216 }; + +fn pack_755(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9]: [G; 9] = context.call::<9>(0, 84, &[v_0])?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 41] = context.call::<41>(1, 754, &[v_9])?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); Ok(()) } + +fn pack_755_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9]: [G; 9] = context.call::<9>(0, 84, &[v_0])?; seed.full(8, v_1); seed.full(16, v_2); seed.u8(116, v_3); seed.u8(117, v_4); seed.u8(118, v_5); seed.u8(119, v_6); seed.u8(120, v_7); seed.u8(121, v_8); seed.u32(108, v_9); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 41] = context.call::<41>(1, 754, &[v_9])?; seed.u8(122, v_10); seed.full(24, v_11); seed.u8(123, v_12); seed.full(32, v_13); seed.full(40, v_14); seed.u8(124, v_15); seed.u8(125, v_16); seed.u8(126, v_17); seed.u8(127, v_18); seed.u8(128, v_19); seed.u8(129, v_20); seed.u8(130, v_21); seed.full(48, v_22); seed.full(56, v_23); seed.u8(131, v_24); seed.u8(132, v_25); seed.u8(133, v_26); seed.u8(134, v_27); seed.u8(135, v_28); seed.u8(136, v_29); seed.u8(137, v_30); seed.full(64, v_31); seed.full(72, v_32); seed.u8(138, v_33); seed.u8(139, v_34); seed.u8(140, v_35); seed.u8(141, v_36); seed.u8(142, v_37); seed.u8(143, v_38); seed.u8(144, v_39); seed.full(80, v_40); seed.full(88, v_41); seed.u8(145, v_42); seed.u8(146, v_43); seed.u8(147, v_44); seed.u8(148, v_45); seed.u8(149, v_46); seed.u8(150, v_47); seed.u8(151, v_48); seed.u32(112, v_49); seed.full(96, v_50); Ok(()) } + +fn write_755(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9]: [G; 9] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 41] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_50.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_755: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 104, 8, 16, 116, 117, 118, 119, 120, 121, 108, 122, 24, 123, 32, 40, 124, 125, 126, 127, 128, 129, 130, 48, 56, 131, 132, 133, 134, 135, 136, 137, 64, 72, 138, 139, 140, 141, 142, 143, 144, 80, 88, 145, 146, 147, 148, 149, 150, 151, 112, 96], bytes: 152 }; + +fn pack_762(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 18] = context.load::<18>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(2, &[v_19, v_19, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(3, 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])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.returned::<1>(4)?; seed[22] = v_22.as_canonical_u64(); Ok(()) } + +fn pack_762_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 18] = context.load::<18>(0, v_0)?; seed.u8(28, v_1); seed.u8(29, v_2); seed.u8(30, v_3); seed.u8(31, v_4); seed.u8(32, v_5); seed.u8(33, v_6); seed.u8(34, v_7); seed.u8(35, v_8); seed.u8(36, v_9); seed.u8(37, v_10); seed.u8(38, v_11); seed.u8(39, v_12); seed.u8(40, v_13); seed.u8(41, v_14); seed.u8(42, v_15); seed.u8(43, v_16); seed.u8(44, v_17); seed.u32(12, v_18); let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(2, &[v_19, v_19, v_19])?; seed.u32(16, v_20); let [v_21]: [G; 1] = context.call::<1>(3, 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])?; seed.u32(20, v_21); let [v_22]: [G; 1] = context.returned::<1>(4)?; seed.u32(24, v_22); Ok(()) } + +fn write_762(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 18] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_762: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 12, 16, 20, 24], bytes: 48 }; + +fn pack_771(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 19] = context.load::<19>(0, v_1)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39]: [G; 11] = context.load::<11>(1, v_0)?; seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 11] = context.load::<11>(2, v_0)?; seed[30] = v_40.as_canonical_u64(); seed[31] = v_41.as_canonical_u64(); seed[32] = v_42.as_canonical_u64(); seed[33] = v_43.as_canonical_u64(); seed[34] = v_44.as_canonical_u64(); seed[35] = v_45.as_canonical_u64(); seed[36] = v_46.as_canonical_u64(); seed[37] = v_47.as_canonical_u64(); seed[38] = v_48.as_canonical_u64(); seed[39] = v_49.as_canonical_u64(); seed[40] = v_50.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { _ => { match v_41.as_canonical_u64() { _ => { let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.call::<8>(7, 16, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[41] = v_52.as_canonical_u64(); seed[42] = v_53.as_canonical_u64(); seed[43] = v_54.as_canonical_u64(); seed[44] = v_55.as_canonical_u64(); seed[45] = v_56.as_canonical_u64(); seed[46] = v_57.as_canonical_u64(); seed[47] = v_58.as_canonical_u64(); seed[48] = v_59.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(771, v_40)) }, } }, _ => { Err(no_match(771, v_10)) }, } } + +fn pack_771_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 19] = context.load::<19>(0, v_1)?; seed.u8(122, v_10); seed.full(24, v_11); seed.full(32, v_12); seed.u8(123, v_13); seed.u8(124, v_14); seed.u8(125, v_15); seed.u8(126, v_16); seed.u8(127, v_17); seed.u8(128, v_18); seed.full(40, v_19); seed.full(48, v_20); seed.u8(129, v_21); seed.u8(130, v_22); seed.u8(131, v_23); seed.u8(132, v_24); seed.u8(133, v_25); seed.u8(134, v_26); seed.u32(104, v_27); seed.u32(108, v_28); match v_10.as_canonical_u64() { 1u64 => { let [v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39]: [G; 11] = context.load::<11>(1, v_0)?; seed.u8(135, v_29); seed.full(56, v_30); seed.full(64, v_31); seed.u8(136, v_32); seed.u8(137, v_33); seed.u8(138, v_34); seed.u8(139, v_35); seed.u8(140, v_36); seed.u8(141, v_37); seed.full(72, v_38); seed.u32(112, v_39); Ok(()) }, 0u64 => { let [v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 11] = context.load::<11>(2, v_0)?; seed.u8(135, v_40); seed.full(56, v_41); seed.full(64, v_42); seed.u8(136, v_43); seed.u8(137, v_44); seed.u8(138, v_45); seed.u8(139, v_46); seed.u8(140, v_47); seed.u8(141, v_48); seed.full(72, v_49); seed.u32(112, v_50); match v_40.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { _ => { match v_41.as_canonical_u64() { _ => { let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.call::<8>(7, 16, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(80, v_52); seed.full(88, v_53); seed.u8(142, v_54); seed.u8(143, v_55); seed.u8(144, v_56); seed.u8(145, v_57); seed.u8(146, v_58); seed.u8(147, v_59); Ok(()) }, } }, } }, _ => { Err(no_match(771, v_40)) }, } }, _ => { Err(no_match(771, v_10)) }, } } + +fn write_771(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 19] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_28.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39]: [G; 11] = [G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 20] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_39.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(771, v_29)) }, } }, 0u64 => { let [v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 11] = [G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 20] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_50.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { _ => { match v_41.as_canonical_u64() { _ => { let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = [G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48])]; row[offsets.auxiliaries + 31] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_59.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(771, v_40)) }, } }, _ => { Err(no_match(771, v_10)) }, } } + +static SCHEMA_771: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 96, 100, 8, 16, 116, 117, 118, 119, 120, 121, 122, 24, 32, 123, 124, 125, 126, 127, 128, 40, 48, 129, 130, 131, 132, 133, 134, 104, 108, 135, 56, 64, 136, 137, 138, 139, 140, 141, 72, 112, 80, 88, 142, 143, 144, 145, 146, 147], bytes: 152 }; + +fn pack_774(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 50] = context.load::<50>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); Ok(()) } + +fn pack_774_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 50] = context.load::<50>(0, v_1)?; seed.u8(112, v_2); seed.full(8, v_3); seed.full(16, v_4); seed.u8(113, v_5); seed.u8(114, v_6); seed.u8(115, v_7); seed.u8(116, v_8); seed.u8(117, v_9); seed.u8(118, v_10); seed.u8(119, v_11); seed.full(24, v_12); seed.u8(120, v_13); seed.full(32, v_14); seed.full(40, v_15); seed.u8(121, v_16); seed.u8(122, v_17); seed.u8(123, v_18); seed.u8(124, v_19); seed.u8(125, v_20); seed.u8(126, v_21); seed.u8(127, v_22); seed.full(48, v_23); seed.full(56, v_24); seed.u8(128, v_25); seed.u8(129, v_26); seed.u8(130, v_27); seed.u8(131, v_28); seed.u8(132, v_29); seed.u8(133, v_30); seed.u8(134, v_31); seed.full(64, v_32); seed.full(72, v_33); seed.u8(135, v_34); seed.u8(136, v_35); seed.u8(137, v_36); seed.u8(138, v_37); seed.u8(139, v_38); seed.u8(140, v_39); seed.u8(141, v_40); seed.full(80, v_41); seed.full(88, v_42); seed.u8(142, v_43); seed.u8(143, v_44); seed.u8(144, v_45); seed.u8(145, v_46); seed.u8(146, v_47); seed.u8(147, v_48); seed.u8(148, v_49); seed.u32(104, v_50); seed.u32(108, v_51); Ok(()) } + +fn write_774(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 50] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_51.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(774, v_2)) }, } } + +static SCHEMA_774: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 96, 100, 112, 8, 16, 113, 114, 115, 116, 117, 118, 119, 24, 120, 32, 40, 121, 122, 123, 124, 125, 126, 127, 48, 56, 128, 129, 130, 131, 132, 133, 134, 64, 72, 135, 136, 137, 138, 139, 140, 141, 80, 88, 142, 143, 144, 145, 146, 147, 148, 104, 108], bytes: 152 }; + +fn pack_780(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9, v_10]: [G; 2] = context.io_info(1, v_8, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7])?; seed[9] = v_9.as_canonical_u64(); seed[10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(2, 5, &[v_8, v_9, v_10])?; seed[11] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(103)]; let [v_13]: [G; 1] = [G::from_u64(230)]; let [v_14]: [G; 1] = [G::from_u64(9)]; let [v_15]: [G; 1] = [G::from_u64(106)]; let [v_16]: [G; 1] = [G::from_u64(133)]; let [v_17]: [G; 1] = [G::from_u64(174)]; let [v_18]: [G; 1] = [G::from_u64(187)]; let [v_19]: [G; 1] = [G::from_u64(114)]; let [v_20]: [G; 1] = [G::from_u64(243)]; let [v_21]: [G; 1] = [G::from_u64(110)]; let [v_22]: [G; 1] = [G::from_u64(60)]; let [v_23]: [G; 1] = [G::from_u64(58)]; let [v_24]: [G; 1] = [G::from_u64(245)]; let [v_25]: [G; 1] = [G::from_u64(79)]; let [v_26]: [G; 1] = [G::from_u64(165)]; let [v_27]: [G; 1] = [G::from_u64(127)]; let [v_28]: [G; 1] = [G::from_u64(82)]; let [v_29]: [G; 1] = [G::from_u64(14)]; let [v_30]: [G; 1] = [G::from_u64(81)]; let [v_31]: [G; 1] = [G::from_u64(140)]; let [v_32]: [G; 1] = [G::from_u64(104)]; let [v_33]: [G; 1] = [G::from_u64(5)]; let [v_34]: [G; 1] = [G::from_u64(155)]; let [v_35]: [G; 1] = [G::from_u64(171)]; let [v_36]: [G; 1] = [G::from_u64(217)]; let [v_37]: [G; 1] = [G::from_u64(131)]; let [v_38]: [G; 1] = [G::from_u64(31)]; let [v_39]: [G; 1] = [G::from_u64(25)]; let [v_40]: [G; 1] = [G::from_u64(205)]; let [v_41]: [G; 1] = [G::from_u64(224)]; let [v_42]: [G; 1] = [G::from_u64(91)]; let [v_43]: [G; 1] = [G::from_u64(1)]; let [v_44]: [G; 1] = context.store(35, &[v_43, v_43, v_43])?; seed[12] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.store(36, &[v_8, v_8, v_8, v_8, v_8, v_8, v_8, v_8])?; seed[13] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = context.store(37, &[v_12, v_13, v_14, v_15, v_16, v_17, v_12, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42])?; seed[14] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = context.store(38, &[v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43])?; seed[15] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.call::<1>(39, 26, &[v_11, v_44, v_8, v_8, v_45, v_46, v_47])?; seed[16] = v_48.as_canonical_u64(); let [v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80]: [G; 32] = context.call::<32>(40, 25, &[v_48])?; seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); seed[23] = v_55.as_canonical_u64(); seed[24] = v_56.as_canonical_u64(); seed[25] = v_57.as_canonical_u64(); seed[26] = v_58.as_canonical_u64(); seed[27] = v_59.as_canonical_u64(); seed[28] = v_60.as_canonical_u64(); seed[29] = v_61.as_canonical_u64(); seed[30] = v_62.as_canonical_u64(); seed[31] = v_63.as_canonical_u64(); seed[32] = v_64.as_canonical_u64(); seed[33] = v_65.as_canonical_u64(); seed[34] = v_66.as_canonical_u64(); seed[35] = v_67.as_canonical_u64(); seed[36] = v_68.as_canonical_u64(); seed[37] = v_69.as_canonical_u64(); seed[38] = v_70.as_canonical_u64(); seed[39] = v_71.as_canonical_u64(); seed[40] = v_72.as_canonical_u64(); seed[41] = v_73.as_canonical_u64(); seed[42] = v_74.as_canonical_u64(); seed[43] = v_75.as_canonical_u64(); seed[44] = v_76.as_canonical_u64(); seed[45] = v_77.as_canonical_u64(); seed[46] = v_78.as_canonical_u64(); seed[47] = v_79.as_canonical_u64(); seed[48] = v_80.as_canonical_u64(); let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(93, 82, &[v_11])?; seed[49] = v_132.as_canonical_u64(); seed[50] = v_133.as_canonical_u64(); seed[51] = v_134.as_canonical_u64(); seed[52] = v_135.as_canonical_u64(); seed[53] = v_136.as_canonical_u64(); seed[54] = v_137.as_canonical_u64(); seed[55] = v_138.as_canonical_u64(); seed[56] = v_139.as_canonical_u64(); seed[57] = v_140.as_canonical_u64(); seed[58] = v_141.as_canonical_u64(); let [v_148, v_149]: [G; 2] = context.call::<2>(102, 80, &[v_141])?; seed[59] = v_148.as_canonical_u64(); seed[60] = v_149.as_canonical_u64(); let [v_151, v_152]: [G; 2] = context.call::<2>(105, 80, &[v_149])?; seed[61] = v_151.as_canonical_u64(); seed[62] = v_152.as_canonical_u64(); match v_133.as_canonical_u64() { 4u64 => { let [v_154, v_155]: [G; 2] = context.call::<2>(108, 99, &[v_152])?; seed[63] = v_154.as_canonical_u64(); seed[64] = v_155.as_canonical_u64(); let [v_156, v_157, v_158]: [G; 3] = context.call::<3>(109, 746, &[v_155])?; seed[65] = v_156.as_canonical_u64(); seed[66] = v_157.as_canonical_u64(); seed[67] = v_158.as_canonical_u64(); let [v_159, v_160, v_161]: [G; 3] = context.load::<3>(110, v_158)?; seed[68] = v_159.as_canonical_u64(); seed[69] = v_160.as_canonical_u64(); seed[70] = v_161.as_canonical_u64(); match v_156.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_162]: [G; 1] = context.call::<1>(113, 735, &[v_157])?; seed[71] = v_162.as_canonical_u64(); let [v_163]: [G; 1] = [G::from_u64(1)]; let [v_164, v_165, v_166, v_167, v_168, v_169]: [G; 6] = context.call::<6>(115, 736, &[v_162, v_163, v_163, v_163, v_163, v_163, v_163])?; seed[72] = v_164.as_canonical_u64(); seed[73] = v_165.as_canonical_u64(); seed[74] = v_166.as_canonical_u64(); seed[75] = v_167.as_canonical_u64(); seed[76] = v_168.as_canonical_u64(); seed[77] = v_169.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(780, v_156)) }, } }, 5u64 => { let [v_172, v_173]: [G; 2] = context.call::<2>(120, 99, &[v_152])?; seed[63] = v_172.as_canonical_u64(); seed[64] = v_173.as_canonical_u64(); let [v_174, v_175, v_176]: [G; 3] = context.call::<3>(121, 746, &[v_173])?; seed[65] = v_174.as_canonical_u64(); seed[66] = v_175.as_canonical_u64(); seed[67] = v_176.as_canonical_u64(); let [v_177, v_178, v_179]: [G; 3] = context.load::<3>(122, v_176)?; seed[68] = v_177.as_canonical_u64(); seed[69] = v_178.as_canonical_u64(); seed[70] = v_179.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_181, v_182]: [G; 2] = context.call::<2>(127, 99, &[v_152])?; seed[63] = v_181.as_canonical_u64(); seed[64] = v_182.as_canonical_u64(); let [v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237]: [G; 55] = context.call::<55>(128, 761, &[v_182])?; seed[65] = v_183.as_canonical_u64(); seed[66] = v_184.as_canonical_u64(); seed[67] = v_185.as_canonical_u64(); seed[68] = v_186.as_canonical_u64(); seed[69] = v_187.as_canonical_u64(); seed[70] = v_188.as_canonical_u64(); seed[71] = v_189.as_canonical_u64(); seed[72] = v_190.as_canonical_u64(); seed[73] = v_191.as_canonical_u64(); seed[74] = v_192.as_canonical_u64(); seed[75] = v_193.as_canonical_u64(); seed[76] = v_194.as_canonical_u64(); seed[77] = v_195.as_canonical_u64(); seed[78] = v_196.as_canonical_u64(); seed[79] = v_197.as_canonical_u64(); seed[80] = v_198.as_canonical_u64(); seed[81] = v_199.as_canonical_u64(); seed[82] = v_200.as_canonical_u64(); seed[83] = v_201.as_canonical_u64(); seed[84] = v_202.as_canonical_u64(); seed[85] = v_203.as_canonical_u64(); seed[86] = v_204.as_canonical_u64(); seed[87] = v_205.as_canonical_u64(); seed[88] = v_206.as_canonical_u64(); seed[89] = v_207.as_canonical_u64(); seed[90] = v_208.as_canonical_u64(); seed[91] = v_209.as_canonical_u64(); seed[92] = v_210.as_canonical_u64(); seed[93] = v_211.as_canonical_u64(); seed[94] = v_212.as_canonical_u64(); seed[95] = v_213.as_canonical_u64(); seed[96] = v_214.as_canonical_u64(); seed[97] = v_215.as_canonical_u64(); seed[98] = v_216.as_canonical_u64(); seed[99] = v_217.as_canonical_u64(); seed[100] = v_218.as_canonical_u64(); seed[101] = v_219.as_canonical_u64(); seed[102] = v_220.as_canonical_u64(); seed[103] = v_221.as_canonical_u64(); seed[104] = v_222.as_canonical_u64(); seed[105] = v_223.as_canonical_u64(); seed[106] = v_224.as_canonical_u64(); seed[107] = v_225.as_canonical_u64(); seed[108] = v_226.as_canonical_u64(); seed[109] = v_227.as_canonical_u64(); seed[110] = v_228.as_canonical_u64(); seed[111] = v_229.as_canonical_u64(); seed[112] = v_230.as_canonical_u64(); seed[113] = v_231.as_canonical_u64(); seed[114] = v_232.as_canonical_u64(); seed[115] = v_233.as_canonical_u64(); seed[116] = v_234.as_canonical_u64(); seed[117] = v_235.as_canonical_u64(); seed[118] = v_236.as_canonical_u64(); seed[119] = v_237.as_canonical_u64(); let [v_238, v_239, v_240]: [G; 3] = context.load::<3>(129, v_237)?; seed[120] = v_238.as_canonical_u64(); seed[121] = v_239.as_canonical_u64(); seed[122] = v_240.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_243, v_244]: [G; 2] = context.call::<2>(135, 99, &[v_152])?; seed[63] = v_243.as_canonical_u64(); seed[64] = v_244.as_canonical_u64(); let [v_245, v_246]: [G; 2] = context.call::<2>(136, 99, &[v_244])?; seed[65] = v_245.as_canonical_u64(); seed[66] = v_246.as_canonical_u64(); let [v_247, v_248, v_249]: [G; 3] = context.load::<3>(137, v_246)?; seed[67] = v_247.as_canonical_u64(); seed[68] = v_248.as_canonical_u64(); seed[69] = v_249.as_canonical_u64(); Ok(()) }, 9u64 => { Ok(()) }, _ => { Err(no_match(780, v_133)) }, } } + +fn pack_780_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let [v_8]: [G; 1] = [G::from_u64(0)]; let [v_9, v_10]: [G; 2] = context.io_info(1, v_8, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7])?; seed.u32(416, v_9); seed.u32(420, v_10); let [v_11]: [G; 1] = context.call::<1>(2, 5, &[v_8, v_9, v_10])?; seed.u32(424, v_11); let [v_12]: [G; 1] = [G::from_u64(103)]; let [v_13]: [G; 1] = [G::from_u64(230)]; let [v_14]: [G; 1] = [G::from_u64(9)]; let [v_15]: [G; 1] = [G::from_u64(106)]; let [v_16]: [G; 1] = [G::from_u64(133)]; let [v_17]: [G; 1] = [G::from_u64(174)]; let [v_18]: [G; 1] = [G::from_u64(187)]; let [v_19]: [G; 1] = [G::from_u64(114)]; let [v_20]: [G; 1] = [G::from_u64(243)]; let [v_21]: [G; 1] = [G::from_u64(110)]; let [v_22]: [G; 1] = [G::from_u64(60)]; let [v_23]: [G; 1] = [G::from_u64(58)]; let [v_24]: [G; 1] = [G::from_u64(245)]; let [v_25]: [G; 1] = [G::from_u64(79)]; let [v_26]: [G; 1] = [G::from_u64(165)]; let [v_27]: [G; 1] = [G::from_u64(127)]; let [v_28]: [G; 1] = [G::from_u64(82)]; let [v_29]: [G; 1] = [G::from_u64(14)]; let [v_30]: [G; 1] = [G::from_u64(81)]; let [v_31]: [G; 1] = [G::from_u64(140)]; let [v_32]: [G; 1] = [G::from_u64(104)]; let [v_33]: [G; 1] = [G::from_u64(5)]; let [v_34]: [G; 1] = [G::from_u64(155)]; let [v_35]: [G; 1] = [G::from_u64(171)]; let [v_36]: [G; 1] = [G::from_u64(217)]; let [v_37]: [G; 1] = [G::from_u64(131)]; let [v_38]: [G; 1] = [G::from_u64(31)]; let [v_39]: [G; 1] = [G::from_u64(25)]; let [v_40]: [G; 1] = [G::from_u64(205)]; let [v_41]: [G; 1] = [G::from_u64(224)]; let [v_42]: [G; 1] = [G::from_u64(91)]; let [v_43]: [G; 1] = [G::from_u64(1)]; let [v_44]: [G; 1] = context.store(35, &[v_43, v_43, v_43])?; seed.u32(428, v_44); let [v_45]: [G; 1] = context.store(36, &[v_8, v_8, v_8, v_8, v_8, v_8, v_8, v_8])?; seed.u32(432, v_45); let [v_46]: [G; 1] = context.store(37, &[v_12, v_13, v_14, v_15, v_16, v_17, v_12, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42])?; seed.u32(436, v_46); let [v_47]: [G; 1] = context.store(38, &[v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43])?; seed.u32(440, v_47); let [v_48]: [G; 1] = context.call::<1>(39, 26, &[v_11, v_44, v_8, v_8, v_45, v_46, v_47])?; seed.u32(444, v_48); let [v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80]: [G; 32] = context.call::<32>(40, 25, &[v_48])?; seed.full(72, v_49); seed.full(80, v_50); seed.full(88, v_51); seed.full(96, v_52); seed.full(104, v_53); seed.full(112, v_54); seed.full(120, v_55); seed.full(128, v_56); seed.full(136, v_57); seed.full(144, v_58); seed.full(152, v_59); seed.full(160, v_60); seed.full(168, v_61); seed.full(176, v_62); seed.full(184, v_63); seed.full(192, v_64); seed.full(200, v_65); seed.full(208, v_66); seed.full(216, v_67); seed.full(224, v_68); seed.full(232, v_69); seed.full(240, v_70); seed.full(248, v_71); seed.full(256, v_72); seed.full(264, v_73); seed.full(272, v_74); seed.full(280, v_75); seed.full(288, v_76); seed.full(296, v_77); seed.full(304, v_78); seed.full(312, v_79); seed.full(320, v_80); let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(93, 82, &[v_11])?; seed.u8(520, v_132); seed.u8(521, v_133); seed.full(328, v_134); seed.u8(522, v_135); seed.u8(523, v_136); seed.u8(524, v_137); seed.u8(525, v_138); seed.u8(526, v_139); seed.u8(527, v_140); seed.u32(448, v_141); let [v_148, v_149]: [G; 2] = context.call::<2>(102, 80, &[v_141])?; seed.u8(528, v_148); seed.u32(452, v_149); let [v_151, v_152]: [G; 2] = context.call::<2>(105, 80, &[v_149])?; seed.u8(529, v_151); seed.u32(456, v_152); match v_133.as_canonical_u64() { 4u64 => { let [v_154, v_155]: [G; 2] = context.call::<2>(108, 99, &[v_152])?; seed.u32(460, v_154); seed.u32(464, v_155); let [v_156, v_157, v_158]: [G; 3] = context.call::<3>(109, 746, &[v_155])?; seed.u32(468, v_156); seed.u32(472, v_157); seed.u32(476, v_158); let [v_159, v_160, v_161]: [G; 3] = context.load::<3>(110, v_158)?; seed.u8(530, v_159); seed.u8(531, v_160); seed.u8(532, v_161); match v_156.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_162]: [G; 1] = context.call::<1>(113, 735, &[v_157])?; seed.full(336, v_162); let [v_163]: [G; 1] = [G::from_u64(1)]; let [v_164, v_165, v_166, v_167, v_168, v_169]: [G; 6] = context.call::<6>(115, 736, &[v_162, v_163, v_163, v_163, v_163, v_163, v_163])?; seed.full(344, v_164); seed.full(352, v_165); seed.u32(480, v_166); seed.full(360, v_167); seed.u32(484, v_168); seed.u32(488, v_169); Ok(()) }, _ => { Err(no_match(780, v_156)) }, } }, 5u64 => { let [v_172, v_173]: [G; 2] = context.call::<2>(120, 99, &[v_152])?; seed.u32(460, v_172); seed.u32(464, v_173); let [v_174, v_175, v_176]: [G; 3] = context.call::<3>(121, 746, &[v_173])?; seed.u32(468, v_174); seed.u32(472, v_175); seed.u32(476, v_176); let [v_177, v_178, v_179]: [G; 3] = context.load::<3>(122, v_176)?; seed.u8(530, v_177); seed.u8(531, v_178); seed.u8(532, v_179); Ok(()) }, 6u64 => { let [v_181, v_182]: [G; 2] = context.call::<2>(127, 99, &[v_152])?; seed.u32(460, v_181); seed.u32(464, v_182); let [v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237]: [G; 55] = context.call::<55>(128, 761, &[v_182])?; seed.u32(468, v_183); seed.u32(472, v_184); seed.u32(476, v_185); seed.u8(530, v_186); seed.u8(531, v_187); seed.u8(532, v_188); seed.full(336, v_189); seed.full(344, v_190); seed.full(352, v_191); seed.u32(480, v_192); seed.full(360, v_193); seed.u32(484, v_194); seed.u32(488, v_195); seed.u32(492, v_196); seed.u8(533, v_197); seed.u32(496, v_198); seed.u8(534, v_199); seed.u32(500, v_200); seed.u8(535, v_201); seed.u8(536, v_202); seed.u32(504, v_203); seed.u8(537, v_204); seed.u8(538, v_205); seed.u8(539, v_206); seed.full(368, v_207); seed.full(376, v_208); seed.u8(540, v_209); seed.u8(541, v_210); seed.u8(542, v_211); seed.u8(543, v_212); seed.u8(544, v_213); seed.u8(545, v_214); seed.u8(546, v_215); seed.full(384, v_216); seed.full(392, v_217); seed.u8(547, v_218); seed.u8(548, v_219); seed.u8(549, v_220); seed.u8(550, v_221); seed.u8(551, v_222); seed.u8(552, v_223); seed.u8(553, v_224); seed.full(400, v_225); seed.full(408, v_226); seed.u8(554, v_227); seed.u8(555, v_228); seed.u8(556, v_229); seed.u8(557, v_230); seed.u8(558, v_231); seed.u8(559, v_232); seed.u8(560, v_233); seed.u32(508, v_234); seed.u8(561, v_235); seed.u32(512, v_236); seed.u32(516, v_237); let [v_238, v_239, v_240]: [G; 3] = context.load::<3>(129, v_237)?; seed.u8(562, v_238); seed.u8(563, v_239); seed.u8(564, v_240); Ok(()) }, 7u64 => { let [v_243, v_244]: [G; 2] = context.call::<2>(135, 99, &[v_152])?; seed.u32(460, v_243); seed.u32(464, v_244); let [v_245, v_246]: [G; 2] = context.call::<2>(136, 99, &[v_244])?; seed.u32(468, v_245); seed.u32(472, v_246); let [v_247, v_248, v_249]: [G; 3] = context.load::<3>(137, v_246)?; seed.u32(476, v_247); seed.u8(530, v_248); seed.u8(531, v_249); Ok(()) }, 9u64 => { Ok(()) }, _ => { Err(no_match(780, v_133)) }, } } + +fn write_780(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let [v_9, v_10]: [G; 2] = [G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 4] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 5] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 6] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 7] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 8] = v_48.as_canonical_u64(); let [v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80]: [G; 32] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48])]; row[offsets.auxiliaries + 9] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_80.as_canonical_u64(); let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = [G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58])]; row[offsets.auxiliaries + 41] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_141.as_canonical_u64(); let [v_148, v_149]: [G; 2] = [G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 51] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_149.as_canonical_u64(); let [v_151, v_152]: [G; 2] = [G::from_u64(seed[61]), G::from_u64(seed[62])]; row[offsets.auxiliaries + 53] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_152.as_canonical_u64(); match v_133.as_canonical_u64() { 4u64 => { let [v_154, v_155]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_155.as_canonical_u64(); let [v_156, v_157, v_158]: [G; 3] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67])]; row[offsets.auxiliaries + 57] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_158.as_canonical_u64(); let [v_159, v_160, v_161]: [G; 3] = [G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 60] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_161.as_canonical_u64(); match v_156.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_162]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 63] = v_162.as_canonical_u64(); let [v_164, v_165, v_166, v_167, v_168, v_169]: [G; 6] = [G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77])]; row[offsets.auxiliaries + 64] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_169.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(780, v_156)) }, } }, 5u64 => { let [v_172, v_173]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_173.as_canonical_u64(); let [v_174, v_175, v_176]: [G; 3] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67])]; row[offsets.auxiliaries + 57] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_176.as_canonical_u64(); let [v_177, v_178, v_179]: [G; 3] = [G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 60] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_179.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_181, v_182]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_182.as_canonical_u64(); let [v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237]: [G; 55] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119])]; row[offsets.auxiliaries + 57] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_193.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_198.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_199.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_213.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_215.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_223.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_237.as_canonical_u64(); let [v_238, v_239, v_240]: [G; 3] = [G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122])]; row[offsets.auxiliaries + 112] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_240.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_243, v_244]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_244.as_canonical_u64(); let [v_245, v_246]: [G; 2] = [G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 57] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_246.as_canonical_u64(); let [v_247, v_248, v_249]: [G; 3] = [G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 59] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_249.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 9u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(780, v_133)) }, } } + +static SCHEMA_780: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 64, 416, 420, 424, 428, 432, 436, 440, 444, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 520, 521, 328, 522, 523, 524, 525, 526, 527, 448, 528, 452, 529, 456, 460, 464, 468, 472, 476, 530, 531, 532, 336, 344, 352, 480, 360, 484, 488, 492, 533, 496, 534, 500, 535, 536, 504, 537, 538, 539, 368, 376, 540, 541, 542, 543, 544, 545, 546, 384, 392, 547, 548, 549, 550, 551, 552, 553, 400, 408, 554, 555, 556, 557, 558, 559, 560, 508, 561, 512, 516, 562, 563, 564], bytes: 568 }; + +fn pack_783(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6])?; seed[6] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = context.store(4, &[v_5, v_1, v_7])?; seed[7] = v_8.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.call::<1>(6, 783, &[v_4, v_1])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.store(7, &[v_9, v_3, v_10])?; seed[7] = v_11.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(783, v_2)) }, } } + +fn pack_783_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(40, v_2); seed.full(16, v_3); seed.u32(28, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = context.store(3, &[v_6, v_6, v_6])?; seed.u32(32, v_7); let [v_8]: [G; 1] = context.store(4, &[v_5, v_1, v_7])?; seed.u32(36, v_8); Ok(()) }, 0u64 => { let [v_9]: [G; 1] = [G::from_u64(0)]; let [v_10]: [G; 1] = context.call::<1>(6, 783, &[v_4, v_1])?; seed.u32(32, v_10); let [v_11]: [G; 1] = context.store(7, &[v_9, v_3, v_10])?; seed.u32(36, v_11); Ok(()) }, _ => { Err(no_match(783, v_2)) }, } } + +fn write_783(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_11.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(783, v_2)) }, } } + +static SCHEMA_783: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 24, 8, 40, 16, 28, 32, 36], bytes: 48 }; + +fn pack_784(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 784, &[v_10])?; seed[12] = v_12.as_canonical_u64(); seed[13] = v_13.as_canonical_u64(); seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 8] = context.returned::<8>(3)?; seed[20] = v_20.as_canonical_u64(); seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(784, v_1)) }, } } + +fn pack_784_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(208, v_1); seed.full(8, v_2); seed.full(16, v_3); seed.full(24, v_4); seed.full(32, v_5); seed.full(40, v_6); seed.full(48, v_7); seed.full(56, v_8); seed.full(64, v_9); seed.u32(204, v_10); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 784, &[v_10])?; seed.full(72, v_12); seed.full(80, v_13); seed.full(88, v_14); seed.full(96, v_15); seed.full(104, v_16); seed.full(112, v_17); seed.full(120, v_18); seed.full(128, v_19); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 8] = context.returned::<8>(3)?; seed.full(136, v_20); seed.full(144, v_21); seed.full(152, v_22); seed.full(160, v_23); seed.full(168, v_24); seed.full(176, v_25); seed.full(184, v_26); seed.full(192, v_27); Ok(()) }, _ => { Err(no_match(784, v_1)) }, } } + +fn write_784(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10]: [G; 10] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 8] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27])]; row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(784, v_1)) }, } } + +static SCHEMA_784: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 200, 208, 8, 16, 24, 32, 40, 48, 56, 64, 204, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192], bytes: 216 }; + +fn pack_787(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13]: [G; 6] = context.load::<6>(0, v_5)?; seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19]: [G; 6] = context.load::<6>(1, v_6)?; seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); let op_2 = u32_less_than(v_0, v_3); let [v_20]: [G; 1] = [op_2.0]; match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = context.returned::<1>(3)?; seed[21] = v_21.as_canonical_u64(); Ok(()) }, _ => { let [v_22]: [G; 1] = [v_0 - v_3]; match v_22.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_23]: [G; 1] = context.returned::<1>(5)?; seed[21] = v_23.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(787, v_1)) }, } } + +fn pack_787_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13]: [G; 6] = context.load::<6>(0, v_5)?; seed.u8(113, v_8); seed.full(32, v_9); seed.u32(88, v_10); seed.full(40, v_11); seed.u32(92, v_12); seed.u32(96, v_13); let [v_14, v_15, v_16, v_17, v_18, v_19]: [G; 6] = context.load::<6>(1, v_6)?; seed.u8(114, v_14); seed.full(48, v_15); seed.u32(100, v_16); seed.full(56, v_17); seed.u32(104, v_18); seed.u32(108, v_19); let op_2 = u32_less_than(v_0, v_3); let [v_20]: [G; 1] = [op_2.0]; match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = context.returned::<1>(3)?; seed.full(64, v_21); Ok(()) }, _ => { let [v_22]: [G; 1] = [v_0 - v_3]; match v_22.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_23]: [G; 1] = context.returned::<1>(5)?; seed.full(64, v_23); Ok(()) }, } }, } }, _ => { Err(no_match(787, v_1)) }, } } + +fn write_787(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); match v_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13]: [G; 6] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 1] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19]: [G; 6] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 7] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_19.as_canonical_u64(); let op_2 = u32_less_than(v_0, v_3); let [v_20]: [G; 1] = [op_2.0]; row[offsets.auxiliaries + 13] = op_2.1[0].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_2.1[1].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_2.1[2].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_2.1[3].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_2.1[4].as_canonical_u64(); row[offsets.auxiliaries + 18] = op_2.1[5].as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 19] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [v_0 - v_3]; match v_22.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 20] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(787, v_1)) }, } } + +static SCHEMA_787: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 72, 112, 8, 76, 16, 80, 84, 24, 113, 32, 88, 40, 92, 96, 114, 48, 100, 56, 104, 108, 64], bytes: 120 }; + +fn pack_789(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = context.call::<1>(2, 789, &[v_4, v_1])?; seed[6] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = context.store(3, &[v_5, v_3, v_6])?; seed[7] = v_7.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(789, v_2)) }, } } + +fn pack_789_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(44, v_2); seed.full(16, v_3); seed.u32(36, v_4); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_5]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = context.call::<1>(2, 789, &[v_4, v_1])?; seed.full(24, v_6); let [v_7]: [G; 1] = context.store(3, &[v_5, v_3, v_6])?; seed.u32(40, v_7); Ok(()) }, _ => { Err(no_match(789, v_2)) }, } } + +fn write_789(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_6]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(789, v_2)) }, } } + +static SCHEMA_789: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 32, 8, 44, 16, 36, 24, 40], bytes: 48 }; + +fn pack_791(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 36] = context.load::<36>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 8] = context.call::<8>(2, 791, &[v_36])?; seed[38] = v_38.as_canonical_u64(); seed[39] = v_39.as_canonical_u64(); seed[40] = v_40.as_canonical_u64(); seed[41] = v_41.as_canonical_u64(); seed[42] = v_42.as_canonical_u64(); seed[43] = v_43.as_canonical_u64(); seed[44] = v_44.as_canonical_u64(); seed[45] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.returned::<8>(3)?; seed[46] = v_46.as_canonical_u64(); seed[47] = v_47.as_canonical_u64(); seed[48] = v_48.as_canonical_u64(); seed[49] = v_49.as_canonical_u64(); seed[50] = v_50.as_canonical_u64(); seed[51] = v_51.as_canonical_u64(); seed[52] = v_52.as_canonical_u64(); seed[53] = v_53.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(791, v_1)) }, } } + +fn pack_791_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 36] = context.load::<36>(0, v_0)?; seed.u8(224, v_1); seed.full(8, v_2); seed.full(16, v_3); seed.full(24, v_4); seed.u8(225, v_5); seed.u8(226, v_6); seed.u8(227, v_7); seed.u8(228, v_8); seed.u8(229, v_9); seed.u8(230, v_10); seed.full(32, v_11); seed.full(40, v_12); seed.u8(231, v_13); seed.u8(232, v_14); seed.u8(233, v_15); seed.u8(234, v_16); seed.u8(235, v_17); seed.u8(236, v_18); seed.full(48, v_19); seed.full(56, v_20); seed.u8(237, v_21); seed.u8(238, v_22); seed.u8(239, v_23); seed.u8(240, v_24); seed.u8(241, v_25); seed.u8(242, v_26); seed.full(64, v_27); seed.full(72, v_28); seed.u8(243, v_29); seed.u8(244, v_30); seed.u8(245, v_31); seed.u8(246, v_32); seed.u8(247, v_33); seed.u8(248, v_34); seed.full(80, v_35); seed.u32(220, v_36); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 8] = context.call::<8>(2, 791, &[v_36])?; seed.full(88, v_38); seed.full(96, v_39); seed.full(104, v_40); seed.full(112, v_41); seed.full(120, v_42); seed.full(128, v_43); seed.full(136, v_44); seed.full(144, v_45); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.returned::<8>(3)?; seed.full(152, v_46); seed.full(160, v_47); seed.full(168, v_48); seed.full(176, v_49); seed.full(184, v_50); seed.full(192, v_51); seed.full(200, v_52); seed.full(208, v_53); Ok(()) }, _ => { Err(no_match(791, v_1)) }, } } + +fn write_791(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 36] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 8] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45])]; row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = [G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53])]; row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_53.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(791, v_1)) }, } } + +static SCHEMA_791: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 216, 224, 8, 16, 24, 225, 226, 227, 228, 229, 230, 32, 40, 231, 232, 233, 234, 235, 236, 48, 56, 237, 238, 239, 240, 241, 242, 64, 72, 243, 244, 245, 246, 247, 248, 80, 220, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208], bytes: 256 }; + +fn pack_792(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 801, &[v_0, v_1])?; seed[3] = v_2.as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_2)?; seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_792_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = context.call::<1>(0, 801, &[v_0, v_1])?; seed.u32(40, v_2); let [v_3, v_4, v_5]: [G; 3] = context.load::<3>(1, v_2)?; seed.u8(44, v_3); seed.full(24, v_4); seed.full(32, v_5); Ok(()) } + +fn write_792(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); let [v_3, v_4, v_5]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_3.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(792, v_3)) }, } } + +static SCHEMA_792: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 40, 44, 24, 32], bytes: 48 }; + +fn pack_796(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 11] = context.load::<11>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20]: [G; 8] = context.call::<8>(2, 796, &[v_11])?; seed[13] = v_13.as_canonical_u64(); seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); seed[17] = v_17.as_canonical_u64(); seed[18] = v_18.as_canonical_u64(); seed[19] = v_19.as_canonical_u64(); seed[20] = v_20.as_canonical_u64(); let [v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 8] = context.returned::<8>(3)?; seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(796, v_1)) }, } } + +fn pack_796_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 11] = context.load::<11>(0, v_0)?; seed.u8(168, v_1); seed.full(8, v_2); seed.full(16, v_3); seed.u8(169, v_4); seed.u8(170, v_5); seed.u8(171, v_6); seed.u8(172, v_7); seed.u8(173, v_8); seed.u8(174, v_9); seed.full(24, v_10); seed.u32(164, v_11); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20]: [G; 8] = context.call::<8>(2, 796, &[v_11])?; seed.full(32, v_13); seed.full(40, v_14); seed.full(48, v_15); seed.full(56, v_16); seed.full(64, v_17); seed.full(72, v_18); seed.full(80, v_19); seed.full(88, v_20); let [v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 8] = context.returned::<8>(3)?; seed.full(96, v_21); seed.full(104, v_22); seed.full(112, v_23); seed.full(120, v_24); seed.full(128, v_25); seed.full(136, v_26); seed.full(144, v_27); seed.full(152, v_28); Ok(()) }, _ => { Err(no_match(796, v_1)) }, } } + +fn write_796(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 11] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20]: [G; 8] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); let [v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 8] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(796, v_1)) }, } } + +static SCHEMA_796: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 160, 168, 8, 16, 169, 170, 171, 172, 173, 174, 24, 164, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152], bytes: 176 }; + +fn pack_801(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = [v_1 - v_2]; let [v_4]: [G; 1] = context.call::<1>(2, 801, &[v_0, v_3])?; seed[3] = v_4.as_canonical_u64(); let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(3, v_4)?; seed[4] = v_5.as_canonical_u64(); seed[5] = v_6.as_canonical_u64(); seed[6] = v_7.as_canonical_u64(); Ok(()) }, } } + +fn pack_801_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = [v_1 - v_2]; let [v_4]: [G; 1] = context.call::<1>(2, 801, &[v_0, v_3])?; seed.u32(40, v_4); let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(3, v_4)?; seed.u8(44, v_5); seed.full(24, v_6); seed.full(32, v_7); Ok(()) }, } } + +fn write_801(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); match v_5.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(801, v_5)) }, } }, } } + +static SCHEMA_801: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 40, 44, 24, 32], bytes: 48 }; + +fn pack_807(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; match v_2.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; let [v_10]: [G; 1] = context.store(2, &[v_9, v_9, v_9, v_9, v_9, v_9])?; seed[9] = v_10.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.load::<6>(3, v_6)?; seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.load::<6>(4, v_7)?; seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); let op_5 = u32_less_than(v_0, v_4); let [v_23]: [G; 1] = [op_5.0]; match v_23.as_canonical_u64() { 1u64 => { let [v_24, v_25, v_26, v_27, v_28, v_29]: [G; 6] = context.call::<6>(6, 807, &[v_0, v_1, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[21] = v_24.as_canonical_u64(); seed[22] = v_25.as_canonical_u64(); seed[23] = v_26.as_canonical_u64(); seed[24] = v_27.as_canonical_u64(); seed[25] = v_28.as_canonical_u64(); seed[26] = v_29.as_canonical_u64(); let [v_30, v_31, v_32, v_33, v_34, v_35]: [G; 6] = context.returned::<6>(7)?; seed[27] = v_30.as_canonical_u64(); seed[28] = v_31.as_canonical_u64(); seed[29] = v_32.as_canonical_u64(); seed[30] = v_33.as_canonical_u64(); seed[31] = v_34.as_canonical_u64(); seed[32] = v_35.as_canonical_u64(); Ok(()) }, _ => { let [v_36]: [G; 1] = [v_0 - v_4]; match v_36.as_canonical_u64() { 0u64 => { let [v_38]: [G; 1] = context.store(10, &[v_11, v_12, v_13, v_14, v_15, v_16])?; seed[21] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(11, &[v_17, v_18, v_19, v_20, v_21, v_22])?; seed[22] = v_39.as_canonical_u64(); Ok(()) }, _ => { let [v_40, v_41, v_42, v_43, v_44, v_45]: [G; 6] = context.call::<6>(12, 807, &[v_0, v_1, v_17, v_18, v_19, v_20, v_21, v_22])?; seed[21] = v_40.as_canonical_u64(); seed[22] = v_41.as_canonical_u64(); seed[23] = v_42.as_canonical_u64(); seed[24] = v_43.as_canonical_u64(); seed[25] = v_44.as_canonical_u64(); seed[26] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51]: [G; 6] = context.returned::<6>(13)?; seed[27] = v_46.as_canonical_u64(); seed[28] = v_47.as_canonical_u64(); seed[29] = v_48.as_canonical_u64(); seed[30] = v_49.as_canonical_u64(); seed[31] = v_50.as_canonical_u64(); seed[32] = v_51.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(807, v_2)) }, } } + +fn pack_807_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; match v_2.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; let [v_10]: [G; 1] = context.store(2, &[v_9, v_9, v_9, v_9, v_9, v_9])?; seed.u32(128, v_10); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.load::<6>(3, v_6)?; seed.u32(128, v_11); seed.full(32, v_12); seed.u32(132, v_13); seed.full(40, v_14); seed.u32(136, v_15); seed.u32(140, v_16); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.load::<6>(4, v_7)?; seed.u8(177, v_17); seed.full(48, v_18); seed.u32(144, v_19); seed.full(56, v_20); seed.u32(148, v_21); seed.u32(152, v_22); let op_5 = u32_less_than(v_0, v_4); let [v_23]: [G; 1] = [op_5.0]; match v_23.as_canonical_u64() { 1u64 => { let [v_24, v_25, v_26, v_27, v_28, v_29]: [G; 6] = context.call::<6>(6, 807, &[v_0, v_1, v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u32(156, v_24); seed.full(64, v_25); seed.full(72, v_26); seed.full(80, v_27); seed.u32(160, v_28); seed.u32(164, v_29); let [v_30, v_31, v_32, v_33, v_34, v_35]: [G; 6] = context.returned::<6>(7)?; seed.u8(178, v_30); seed.full(88, v_31); seed.full(96, v_32); seed.full(104, v_33); seed.u32(168, v_34); seed.u32(172, v_35); Ok(()) }, _ => { let [v_36]: [G; 1] = [v_0 - v_4]; match v_36.as_canonical_u64() { 0u64 => { let [v_38]: [G; 1] = context.store(10, &[v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u32(156, v_38); let [v_39]: [G; 1] = context.store(11, &[v_17, v_18, v_19, v_20, v_21, v_22])?; seed.full(64, v_39); Ok(()) }, _ => { let [v_40, v_41, v_42, v_43, v_44, v_45]: [G; 6] = context.call::<6>(12, 807, &[v_0, v_1, v_17, v_18, v_19, v_20, v_21, v_22])?; seed.u32(156, v_40); seed.full(64, v_41); seed.full(72, v_42); seed.full(80, v_43); seed.u32(160, v_44); seed.u32(164, v_45); let [v_46, v_47, v_48, v_49, v_50, v_51]: [G; 6] = context.returned::<6>(13)?; seed.u8(178, v_46); seed.full(88, v_47); seed.full(96, v_48); seed.full(104, v_49); seed.u32(168, v_50); seed.u32(172, v_51); Ok(()) }, } }, } }, _ => { Err(no_match(807, v_2)) }, } } + +fn write_807(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); match v_2.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_16.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 7] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); let op_5 = u32_less_than(v_0, v_4); let [v_23]: [G; 1] = [op_5.0]; row[offsets.auxiliaries + 13] = op_5.1[0].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_5.1[1].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_5.1[2].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_5.1[3].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_5.1[4].as_canonical_u64(); row[offsets.auxiliaries + 18] = op_5.1[5].as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24, v_25, v_26, v_27, v_28, v_29]: [G; 6] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_29.as_canonical_u64(); let [v_30, v_31, v_32, v_33, v_34, v_35]: [G; 6] = [G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 25] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 19] = (v_23 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_36]: [G; 1] = [v_0 - v_4]; match v_36.as_canonical_u64() { 0u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 20] = (v_36 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_40, v_41, v_42, v_43, v_44, v_45]: [G; 6] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 21] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51]: [G; 6] = [G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 27] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_51.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(807, v_2)) }, } } + +static SCHEMA_807: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 112, 8, 176, 16, 116, 24, 120, 124, 128, 32, 132, 40, 136, 140, 177, 48, 144, 56, 148, 152, 156, 64, 72, 80, 160, 164, 178, 88, 96, 104, 168, 172], bytes: 184 }; + +fn pack_808(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; match v_0.as_canonical_u64() { 1u64 => { let [v_15, v_16, v_17, v_18, v_19, v_20]: [G; 6] = context.returned::<6>(0)?; seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); Ok(()) }, _ => { let [v_22]: [G; 1] = context.store(2, &[v_3, v_4, v_5, v_6, v_7, v_8])?; seed[16] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.store(3, &[v_9, v_10, v_11, v_12, v_13, v_14])?; seed[17] = v_23.as_canonical_u64(); Ok(()) }, } } + +fn pack_808_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; match v_0.as_canonical_u64() { 1u64 => { let [v_15, v_16, v_17, v_18, v_19, v_20]: [G; 6] = context.returned::<6>(0)?; seed.u32(128, v_15); seed.u32(132, v_16); seed.full(96, v_17); seed.full(104, v_18); seed.u32(136, v_19); seed.u32(140, v_20); Ok(()) }, _ => { let [v_22]: [G; 1] = context.store(2, &[v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u32(128, v_22); let [v_23]: [G; 1] = context.store(3, &[v_9, v_10, v_11, v_12, v_13, v_14])?; seed.u32(132, v_23); Ok(()) }, } } + +fn write_808(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); match v_0.as_canonical_u64() { 1u64 => { let [v_15, v_16, v_17, v_18, v_19, v_20]: [G; 6] = [G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21])]; row[offsets.auxiliaries + 1] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_20.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 2] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 3] = v_23.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_808: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 112, 116, 64, 72, 80, 88, 120, 124, 128, 132, 96, 104, 136, 140], bytes: 144 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(256)), Op::Mul(9, 66), Op::Add(67, 8), Op::Mul(68, 66), Op::Add(69, 7), Op::Mul(70, 66), Op::Add(71, 6), Op::Mul(72, 66), Op::Add(73, 5), Op::Mul(74, 66), Op::Add(75, 4), Op::Mul(76, 66), Op::Add(77, 3), Op::Mul(41, 66), Op::Add(79, 40), Op::Mul(80, 66), Op::Add(81, 39), Op::Mul(82, 66), Op::Add(83, 38), Op::Mul(84, 66), Op::Add(85, 37), Op::Mul(86, 66), Op::Add(87, 36), Op::Mul(88, 66), Op::Add(89, 35), Op::Sub(78, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 92), Op::Add(93, 15), Op::Mul(94, 92), Op::Add(95, 14), Op::Mul(96, 92), Op::Add(97, 13), Op::Mul(98, 92), Op::Add(99, 12), Op::Mul(100, 92), Op::Add(101, 11), Op::Mul(102, 92), Op::Add(103, 10), Op::Mul(48, 92), Op::Add(105, 47), Op::Mul(106, 92), Op::Add(107, 46), Op::Mul(108, 92), Op::Add(109, 45), Op::Mul(110, 92), Op::Add(111, 44), Op::Mul(112, 92), Op::Add(113, 43), Op::Mul(114, 92), Op::Add(115, 42), Op::Sub(104, 116)], ctrl: Ctrl::Match(117, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(23, 118), Op::Add(119, 22), Op::Mul(120, 118), Op::Add(121, 21), Op::Mul(122, 118), Op::Add(123, 20), Op::Mul(124, 118), Op::Add(125, 19), Op::Mul(126, 118), Op::Add(127, 18), Op::Mul(128, 118), Op::Add(129, 17), Op::Mul(55, 118), Op::Add(131, 54), Op::Mul(132, 118), Op::Add(133, 53), Op::Mul(134, 118), Op::Add(135, 52), Op::Mul(136, 118), Op::Add(137, 51), Op::Mul(138, 118), Op::Add(139, 50), Op::Mul(140, 118), Op::Add(141, 49), Op::Sub(130, 142)], ctrl: Ctrl::Match(143, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(30, 144), Op::Add(145, 29), Op::Mul(146, 144), Op::Add(147, 28), Op::Mul(148, 144), Op::Add(149, 27), Op::Mul(150, 144), Op::Add(151, 26), Op::Mul(152, 144), Op::Add(153, 25), Op::Mul(154, 144), Op::Add(155, 24), Op::Mul(62, 144), Op::Add(157, 61), Op::Mul(158, 144), Op::Add(159, 60), Op::Mul(160, 144), Op::Add(161, 59), Op::Mul(162, 144), Op::Add(163, 58), Op::Mul(164, 144), Op::Add(165, 57), Op::Mul(166, 144), Op::Add(167, 56), Op::Sub(156, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(33, 170), Op::Add(171, 32), Op::Mul(172, 170), Op::Add(173, 31), Op::Mul(65, 170), Op::Add(175, 64), Op::Mul(176, 170), Op::Add(177, 63), Op::Sub(174, 178)], ctrl: Ctrl::Match(179, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![180]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![180]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![170]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![144]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![118]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![92]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 66, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Sub(2, 34)], ctrl: Ctrl::Match(66, [(G::from_u64(0), Block { ops: vec![Op::Call(1, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![67]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![67]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 66, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(4294967295)), Op::Call(0, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("list depth exceeds u32".into())), Op::Add(0, 3)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Sub(2, 3), Op::Call(4, vec![0, 4, 5], 1, false), Op::IORead(0, 1, 1), Op::Const(G::from_u64(0)), Op::Store(vec![8, 7, 6])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![Op::Call(4, vec![0, 1, 2], 1, true), Op::Call(803, vec![3], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Mul(12, 12), Op::AssertEq(vec![13], vec![12], Some("u32_add: carry is not boolean".into()))], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::U8RangeCheck(12, 13), Op::U8RangeCheck(14, 15), Op::Const(G::from_u64(1)), Op::Sub(16, 17), Op::Const(G::from_u64(2)), Op::Sub(16, 19), Op::Mul(18, 20), Op::Mul(16, 21), Op::Const(G::from_u64(0)), Op::AssertEq(vec![22], vec![23], Some("u32_add3: carry is not in {0, 1, 2}".into()))], ctrl: Ctrl::Return(0, vec![12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 4), Op::U8Xor(1, 5), Op::U8Xor(2, 6), Op::U8Xor(3, 7)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 0, 1]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 0]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit7(0, 4), Op::U8XorSplit7(1, 5), Op::U8XorSplit7(2, 6), Op::U8XorSplit7(3, 7), Op::Add(8, 11), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit4(0, 4), Op::U8XorSplit4(1, 5), Op::U8XorSplit4(2, 6), Op::U8XorSplit4(3, 7), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9), Op::Add(8, 11)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 8), Op::Sub(1, 9), Op::Sub(2, 10), Op::Sub(3, 11), Op::Sub(4, 12), Op::Sub(5, 13), Op::Sub(6, 14), Op::Sub(7, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![24]) }))) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::U8Add(0, 8), Op::U8Add(1, 9), Op::U8Add(18, 17), Op::Add(19, 21), Op::U8Add(2, 10), Op::U8Add(23, 22), Op::Add(24, 26), Op::U8Add(3, 11), Op::U8Add(28, 27), Op::Add(29, 31), Op::U8Add(4, 12), Op::U8Add(33, 32), Op::Add(34, 36), Op::U8Add(5, 13), Op::U8Add(38, 37), Op::Add(39, 41), Op::U8Add(6, 14), Op::U8Add(43, 42), Op::Add(44, 46), Op::U8Add(7, 15), Op::U8Add(48, 47), Op::Add(49, 51)], ctrl: Ctrl::Return(0, vec![16, 20, 25, 30, 35, 40, 45, 50, 52]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(255), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(255)), Op::Const(G::from_u64(1)), Op::Sub(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".into())), Op::Const(G::from_u64(256)), Op::Mul(9, 1), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Const(G::from_u64(16777216)), Op::Mul(13, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 6), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(0, 25)], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Const(G::from_u64(65536)), Op::Mul(6, 2), Op::Const(G::from_u64(16777216)), Op::Mul(8, 3), Op::Add(7, 9), Op::Add(5, 10), Op::Add(0, 11)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Const(G::from_u64(65536)), Op::Mul(34, 2), Op::Const(G::from_u64(16777216)), Op::Mul(36, 3), Op::Add(35, 37), Op::Add(33, 38), Op::Add(0, 39), Op::Mul(32, 5), Op::Mul(34, 6), Op::Mul(36, 7), Op::Add(42, 43), Op::Add(41, 44), Op::Add(4, 45), Op::Mul(32, 9), Op::Mul(34, 10), Op::Mul(36, 11), Op::Add(48, 49), Op::Add(47, 50), Op::Add(8, 51), Op::Mul(32, 13), Op::Mul(34, 14), Op::Mul(36, 15), Op::Add(54, 55), Op::Add(53, 56), Op::Add(12, 57), Op::Mul(32, 17), Op::Mul(34, 18), Op::Mul(36, 19), Op::Add(60, 61), Op::Add(59, 62), Op::Add(16, 63), Op::Mul(32, 21), Op::Mul(34, 22), Op::Mul(36, 23), Op::Add(66, 67), Op::Add(65, 68), Op::Add(20, 69), Op::Mul(32, 25), Op::Mul(34, 26), Op::Mul(36, 27), Op::Add(72, 73), Op::Add(71, 74), Op::Add(24, 75), Op::Mul(32, 29), Op::Mul(34, 30), Op::Mul(36, 31), Op::Add(78, 79), Op::Add(77, 80), Op::Add(28, 81)], ctrl: Ctrl::Return(0, vec![40, 46, 52, 58, 64, 70, 76, 82]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(26, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(25, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_22() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![64, 64, 64]), Op::Const(G::from_u64(0)), Op::Store(vec![66, 66, 66, 66, 66, 66, 66, 66]), Op::Store(vec![33, 34, 35, 36, 37, 38, 33, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]), Op::Store(vec![64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64]), Op::Call(26, vec![0, 65, 66, 66, 67, 68, 69], 1, false), Op::Call(25, vec![70], 32, false), Op::AssertEq(vec![71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102], vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], Some("blake3 of the supplied bytes != the address they were fetched under".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_23() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(26, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(25, vec![38], 32, false), Op::Store(vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70])], ctrl: Ctrl::Return(0, vec![71]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 39, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_24() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![68, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(24, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68], 34, false)], ctrl: Ctrl::Match(69, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![103, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 102]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(34, 102)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Mul(104, 33), Op::Add(103, 170), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(34, vec![172, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 174, 175, 176, 177, 178, 179, 174, 180, 181, 182, 183, 184, 185, 186, 187, 188, 172, 172, 172, 172, 172, 172, 172, 172, 173, 172, 172, 172, 171, 172, 172, 172, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![172, 102, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220])], ctrl: Ctrl::Return(2, vec![172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 221]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(34, vec![170, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 172, 173, 174, 175, 176, 177, 172, 178, 179, 180, 181, 182, 183, 184, 185, 186, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 170, 170, 103, 170, 170, 170, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![170, 102, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218])], ctrl: Ctrl::Return(3, vec![170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 219]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_25() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(34, 2)], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(24, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 69], 34, false)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Call(25, vec![103], 32, false)], ctrl: Ctrl::Return(1, vec![104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![104, 103, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]), Op::Call(25, vec![105], 32, false)], ctrl: Ctrl::Return(2, vec![106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_26() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(29, vec![1, 2, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 1])], ctrl: Ctrl::Match(2, [(G::from_u64(63), Block { ops: vec![Op::Call(30, vec![9, 11, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 12), Op::Add(3, 12), Op::Call(26, vec![9, 11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_27() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 96)], ctrl: Ctrl::Match(97, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 99)], ctrl: Ctrl::Match(100, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 102)], ctrl: Ctrl::Match(103, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 105)], ctrl: Ctrl::Match(106, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 108)], ctrl: Ctrl::Match(109, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 111)], ctrl: Ctrl::Match(112, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 114)], ctrl: Ctrl::Match(115, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 117)], ctrl: Ctrl::Match(118, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 123)], ctrl: Ctrl::Match(124, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 126)], ctrl: Ctrl::Match(127, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 129)], ctrl: Ctrl::Match(130, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 132)], ctrl: Ctrl::Match(133, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 135)], ctrl: Ctrl::Match(136, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 138)], ctrl: Ctrl::Match(139, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 141)], ctrl: Ctrl::Match(142, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 144)], ctrl: Ctrl::Match(145, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 147)], ctrl: Ctrl::Match(148, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 150)], ctrl: Ctrl::Match(151, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 153)], ctrl: Ctrl::Match(154, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 156)], ctrl: Ctrl::Match(157, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 159)], ctrl: Ctrl::Match(160, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 165)], ctrl: Ctrl::Match(166, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 171)], ctrl: Ctrl::Match(172, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 174)], ctrl: Ctrl::Match(175, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 177)], ctrl: Ctrl::Match(178, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 180)], ctrl: Ctrl::Match(181, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 183)], ctrl: Ctrl::Match(184, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 186)], ctrl: Ctrl::Match(187, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 189)], ctrl: Ctrl::Match(190, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_28() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(28, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_29() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Add(6, 7), Op::Add(8, 17), Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(34, vec![51, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 60, 61, 62, 63, 64, 65, 60, 66, 67, 68, 69, 70, 71, 72, 73, 74, 52, 53, 54, 55, 56, 57, 58, 59, 51, 51, 51, 51, 18, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51], 32, false), Op::Store(vec![51, 5, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106])], ctrl: Ctrl::Return(0, vec![107]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Load(32, 4), Op::Store(vec![9, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41])], ctrl: Ctrl::Return(9, vec![42]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(8, 3), Op::Call(6, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Sub(2, 1), Op::EqZero(19), Op::Mul(20, 6), Op::Add(18, 21), Op::Add(7, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(28, vec![0, 25], 1, false), Op::Call(27, vec![26], 64, false), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(34, vec![138, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 123, 129, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 14, 15, 16, 1, 138, 138, 138, 23, 138, 138, 138, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90], 32, false), Op::Store(vec![138, 5, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170])], ctrl: Ctrl::Return(10, vec![171]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_30() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(27, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(798, vec![0], 1, false), Op::Load(8, 3), Op::Call(6, vec![74, 75, 76, 77, 78, 79, 80, 81], 1, false), Op::Mul(73, 82), Op::Mul(8, 83), Op::Add(84, 7), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(0)), Op::Call(34, vec![150, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 74, 75, 76, 77, 78, 79, 80, 81, 149, 150, 150, 150, 85, 150, 150, 150, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Store(vec![150, 5, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182]), Op::Const(G::from_u64(1)), Op::Store(vec![184, 184, 184]), Op::Call(16, vec![74, 75, 76, 77, 78, 79, 80, 81], 8, false), Op::Store(vec![186, 187, 188, 189, 190, 191, 192, 193]), Op::Store(vec![86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]), Op::Call(26, vec![0, 185, 150, 150, 194, 195, 183], 1, false)], ctrl: Ctrl::Return(0, vec![196]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(798, vec![0], 1, false), Op::Mul(73, 7), Op::Call(798, vec![0], 1, false), Op::Load(8, 3), Op::Call(6, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(84, 8), Op::Mul(75, 85), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(86, 90), Op::Add(74, 91), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(34, vec![141, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131, 126, 132, 133, 134, 135, 136, 137, 138, 139, 140, 76, 77, 78, 79, 80, 81, 82, 83, 125, 141, 141, 141, 92, 141, 141, 141, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Const(G::from_u64(1)), Op::Store(vec![174, 174, 174]), Op::Add(2, 174), Op::Store(vec![142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173]), Op::Call(26, vec![0, 175, 141, 176, 3, 177, 5], 1, false)], ctrl: Ctrl::Return(1, vec![178]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_31() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![16, 17, 18, 19]), Op::U8RangeCheck(24, 25), Op::U8RangeCheck(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Const(G::from_u64(2)), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(28, 33), Op::Const(G::from_u64(0)), Op::AssertEq(vec![34], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(12, 24), Op::U8Xor(13, 25), Op::U8Xor(14, 26), Op::U8Xor(15, 27), Op::UnconstrainedU32Add(vec![8, 9, 10, 11], vec![38, 39, 36, 37]), Op::U8RangeCheck(40, 41), Op::U8RangeCheck(42, 43), Op::Mul(44, 44), Op::AssertEq(vec![45], vec![44], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(4, 40), Op::U8XorSplit4(5, 41), Op::U8XorSplit4(6, 42), Op::U8XorSplit4(7, 43), Op::Add(48, 51), Op::Add(50, 53), Op::Add(52, 47), Op::Add(46, 49), Op::UnconstrainedU32Add3(vec![24, 25, 26, 27], vec![54, 55, 56, 57], vec![20, 21, 22, 23]), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::Sub(62, 29), Op::Sub(62, 31), Op::Mul(63, 64), Op::Mul(62, 65), Op::AssertEq(vec![66], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(38, 58), Op::U8Xor(39, 59), Op::U8Xor(36, 60), Op::U8Xor(37, 61), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![68, 69, 70, 67]), Op::U8RangeCheck(71, 72), Op::U8RangeCheck(73, 74), Op::Mul(75, 75), Op::AssertEq(vec![76], vec![75], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(54, 71), Op::U8XorSplit7(55, 72), Op::U8XorSplit7(56, 73), Op::U8XorSplit7(57, 74), Op::Add(77, 80), Op::Add(79, 82), Op::Add(81, 84), Op::Add(83, 78)], ctrl: Ctrl::Return(0, vec![58, 59, 60, 61, 85, 86, 87, 88, 71, 72, 73, 74, 68, 69, 70, 67]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 47, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_32() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![16, 17, 18, 19], vec![64, 65, 66, 67]), Op::U8RangeCheck(128, 129), Op::U8RangeCheck(130, 131), Op::Const(G::from_u64(1)), Op::Sub(132, 133), Op::Const(G::from_u64(2)), Op::Sub(132, 135), Op::Mul(134, 136), Op::Mul(132, 137), Op::Const(G::from_u64(0)), Op::AssertEq(vec![138], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(48, 128), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::UnconstrainedU32Add(vec![32, 33, 34, 35], vec![142, 143, 140, 141]), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::Mul(148, 148), Op::AssertEq(vec![149], vec![148], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(16, 144), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::Add(152, 155), Op::Add(154, 157), Op::Add(156, 151), Op::Add(150, 153), Op::UnconstrainedU32Add3(vec![128, 129, 130, 131], vec![158, 159, 160, 161], vec![68, 69, 70, 71]), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::Sub(166, 133), Op::Sub(166, 135), Op::Mul(167, 168), Op::Mul(166, 169), Op::AssertEq(vec![170], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(142, 162), Op::U8Xor(143, 163), Op::U8Xor(140, 164), Op::U8Xor(141, 165), Op::UnconstrainedU32Add(vec![144, 145, 146, 147], vec![172, 173, 174, 171]), Op::U8RangeCheck(175, 176), Op::U8RangeCheck(177, 178), Op::Mul(179, 179), Op::AssertEq(vec![180], vec![179], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(158, 175), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::Add(181, 184), Op::Add(183, 186), Op::Add(185, 188), Op::Add(187, 182), Op::UnconstrainedU32Add3(vec![4, 5, 6, 7], vec![20, 21, 22, 23], vec![72, 73, 74, 75]), Op::U8RangeCheck(193, 194), Op::U8RangeCheck(195, 196), Op::Sub(197, 133), Op::Sub(197, 135), Op::Mul(198, 199), Op::Mul(197, 200), Op::AssertEq(vec![201], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(52, 193), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::UnconstrainedU32Add(vec![36, 37, 38, 39], vec![204, 205, 202, 203]), Op::U8RangeCheck(206, 207), Op::U8RangeCheck(208, 209), Op::Mul(210, 210), Op::AssertEq(vec![211], vec![210], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(20, 206), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::Add(214, 217), Op::Add(216, 219), Op::Add(218, 213), Op::Add(212, 215), Op::UnconstrainedU32Add3(vec![193, 194, 195, 196], vec![220, 221, 222, 223], vec![76, 77, 78, 79]), Op::U8RangeCheck(224, 225), Op::U8RangeCheck(226, 227), Op::Sub(228, 133), Op::Sub(228, 135), Op::Mul(229, 230), Op::Mul(228, 231), Op::AssertEq(vec![232], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(204, 224), Op::U8Xor(205, 225), Op::U8Xor(202, 226), Op::U8Xor(203, 227), Op::UnconstrainedU32Add(vec![206, 207, 208, 209], vec![234, 235, 236, 233]), Op::U8RangeCheck(237, 238), Op::U8RangeCheck(239, 240), Op::Mul(241, 241), Op::AssertEq(vec![242], vec![241], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(220, 237), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::Add(243, 246), Op::Add(245, 248), Op::Add(247, 250), Op::Add(249, 244), Op::UnconstrainedU32Add3(vec![8, 9, 10, 11], vec![24, 25, 26, 27], vec![80, 81, 82, 83]), Op::U8RangeCheck(255, 256), Op::U8RangeCheck(257, 258), Op::Sub(259, 133), Op::Sub(259, 135), Op::Mul(260, 261), Op::Mul(259, 262), Op::AssertEq(vec![263], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(56, 255), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![266, 267, 264, 265]), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::Mul(272, 272), Op::AssertEq(vec![273], vec![272], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(24, 268), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::Add(276, 279), Op::Add(278, 281), Op::Add(280, 275), Op::Add(274, 277), Op::UnconstrainedU32Add3(vec![255, 256, 257, 258], vec![282, 283, 284, 285], vec![84, 85, 86, 87]), Op::U8RangeCheck(286, 287), Op::U8RangeCheck(288, 289), Op::Sub(290, 133), Op::Sub(290, 135), Op::Mul(291, 292), Op::Mul(290, 293), Op::AssertEq(vec![294], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(266, 286), Op::U8Xor(267, 287), Op::U8Xor(264, 288), Op::U8Xor(265, 289), Op::UnconstrainedU32Add(vec![268, 269, 270, 271], vec![296, 297, 298, 295]), Op::U8RangeCheck(299, 300), Op::U8RangeCheck(301, 302), Op::Mul(303, 303), Op::AssertEq(vec![304], vec![303], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(282, 299), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::Add(305, 308), Op::Add(307, 310), Op::Add(309, 312), Op::Add(311, 306), Op::UnconstrainedU32Add3(vec![12, 13, 14, 15], vec![28, 29, 30, 31], vec![88, 89, 90, 91]), Op::U8RangeCheck(317, 318), Op::U8RangeCheck(319, 320), Op::Sub(321, 133), Op::Sub(321, 135), Op::Mul(322, 323), Op::Mul(321, 324), Op::AssertEq(vec![325], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(60, 317), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::UnconstrainedU32Add(vec![44, 45, 46, 47], vec![328, 329, 326, 327]), Op::U8RangeCheck(330, 331), Op::U8RangeCheck(332, 333), Op::Mul(334, 334), Op::AssertEq(vec![335], vec![334], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(28, 330), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::Add(338, 341), Op::Add(340, 343), Op::Add(342, 337), Op::Add(336, 339), Op::UnconstrainedU32Add3(vec![317, 318, 319, 320], vec![344, 345, 346, 347], vec![92, 93, 94, 95]), Op::U8RangeCheck(348, 349), Op::U8RangeCheck(350, 351), Op::Sub(352, 133), Op::Sub(352, 135), Op::Mul(353, 354), Op::Mul(352, 355), Op::AssertEq(vec![356], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(328, 348), Op::U8Xor(329, 349), Op::U8Xor(326, 350), Op::U8Xor(327, 351), Op::UnconstrainedU32Add(vec![330, 331, 332, 333], vec![358, 359, 360, 357]), Op::U8RangeCheck(361, 362), Op::U8RangeCheck(363, 364), Op::Mul(365, 365), Op::AssertEq(vec![366], vec![365], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(344, 361), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::Add(367, 370), Op::Add(369, 372), Op::Add(371, 374), Op::Add(373, 368), Op::UnconstrainedU32Add3(vec![162, 163, 164, 165], vec![251, 252, 253, 254], vec![96, 97, 98, 99]), Op::U8RangeCheck(379, 380), Op::U8RangeCheck(381, 382), Op::Sub(383, 133), Op::Sub(383, 135), Op::Mul(384, 385), Op::Mul(383, 386), Op::AssertEq(vec![387], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(358, 379), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(357, 382), Op::UnconstrainedU32Add(vec![299, 300, 301, 302], vec![390, 391, 388, 389]), Op::U8RangeCheck(392, 393), Op::U8RangeCheck(394, 395), Op::Mul(396, 396), Op::AssertEq(vec![397], vec![396], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(251, 392), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::Add(400, 403), Op::Add(402, 405), Op::Add(404, 399), Op::Add(398, 401), Op::UnconstrainedU32Add3(vec![379, 380, 381, 382], vec![406, 407, 408, 409], vec![100, 101, 102, 103]), Op::U8RangeCheck(410, 411), Op::U8RangeCheck(412, 413), Op::Sub(414, 133), Op::Sub(414, 135), Op::Mul(415, 416), Op::Mul(414, 417), Op::AssertEq(vec![418], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(390, 410), Op::U8Xor(391, 411), Op::U8Xor(388, 412), Op::U8Xor(389, 413), Op::UnconstrainedU32Add(vec![392, 393, 394, 395], vec![420, 421, 422, 419]), Op::U8RangeCheck(423, 424), Op::U8RangeCheck(425, 426), Op::Mul(427, 427), Op::AssertEq(vec![428], vec![427], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(406, 423), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::Add(429, 432), Op::Add(431, 434), Op::Add(433, 436), Op::Add(435, 430), Op::UnconstrainedU32Add3(vec![224, 225, 226, 227], vec![313, 314, 315, 316], vec![104, 105, 106, 107]), Op::U8RangeCheck(441, 442), Op::U8RangeCheck(443, 444), Op::Sub(445, 133), Op::Sub(445, 135), Op::Mul(446, 447), Op::Mul(445, 448), Op::AssertEq(vec![449], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(172, 441), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(171, 444), Op::UnconstrainedU32Add(vec![361, 362, 363, 364], vec![452, 453, 450, 451]), Op::U8RangeCheck(454, 455), Op::U8RangeCheck(456, 457), Op::Mul(458, 458), Op::AssertEq(vec![459], vec![458], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(313, 454), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::Add(462, 465), Op::Add(464, 467), Op::Add(466, 461), Op::Add(460, 463), Op::UnconstrainedU32Add3(vec![441, 442, 443, 444], vec![468, 469, 470, 471], vec![108, 109, 110, 111]), Op::U8RangeCheck(472, 473), Op::U8RangeCheck(474, 475), Op::Sub(476, 133), Op::Sub(476, 135), Op::Mul(477, 478), Op::Mul(476, 479), Op::AssertEq(vec![480], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(452, 472), Op::U8Xor(453, 473), Op::U8Xor(450, 474), Op::U8Xor(451, 475), Op::UnconstrainedU32Add(vec![454, 455, 456, 457], vec![482, 483, 484, 481]), Op::U8RangeCheck(485, 486), Op::U8RangeCheck(487, 488), Op::Mul(489, 489), Op::AssertEq(vec![490], vec![489], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(468, 485), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::Add(491, 494), Op::Add(493, 496), Op::Add(495, 498), Op::Add(497, 492), Op::UnconstrainedU32Add3(vec![286, 287, 288, 289], vec![375, 376, 377, 378], vec![112, 113, 114, 115]), Op::U8RangeCheck(503, 504), Op::U8RangeCheck(505, 506), Op::Sub(507, 133), Op::Sub(507, 135), Op::Mul(508, 509), Op::Mul(507, 510), Op::AssertEq(vec![511], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(234, 503), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(233, 506), Op::UnconstrainedU32Add(vec![175, 176, 177, 178], vec![514, 515, 512, 513]), Op::U8RangeCheck(516, 517), Op::U8RangeCheck(518, 519), Op::Mul(520, 520), Op::AssertEq(vec![521], vec![520], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(375, 516), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::Add(524, 527), Op::Add(526, 529), Op::Add(528, 523), Op::Add(522, 525), Op::UnconstrainedU32Add3(vec![503, 504, 505, 506], vec![530, 531, 532, 533], vec![116, 117, 118, 119]), Op::U8RangeCheck(534, 535), Op::U8RangeCheck(536, 537), Op::Sub(538, 133), Op::Sub(538, 135), Op::Mul(539, 540), Op::Mul(538, 541), Op::AssertEq(vec![542], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(514, 534), Op::U8Xor(515, 535), Op::U8Xor(512, 536), Op::U8Xor(513, 537), Op::UnconstrainedU32Add(vec![516, 517, 518, 519], vec![544, 545, 546, 543]), Op::U8RangeCheck(547, 548), Op::U8RangeCheck(549, 550), Op::Mul(551, 551), Op::AssertEq(vec![552], vec![551], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(530, 547), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::Add(553, 556), Op::Add(555, 558), Op::Add(557, 560), Op::Add(559, 554), Op::UnconstrainedU32Add3(vec![348, 349, 350, 351], vec![189, 190, 191, 192], vec![120, 121, 122, 123]), Op::U8RangeCheck(565, 566), Op::U8RangeCheck(567, 568), Op::Sub(569, 133), Op::Sub(569, 135), Op::Mul(570, 571), Op::Mul(569, 572), Op::AssertEq(vec![573], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(296, 565), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(295, 568), Op::UnconstrainedU32Add(vec![237, 238, 239, 240], vec![576, 577, 574, 575]), Op::U8RangeCheck(578, 579), Op::U8RangeCheck(580, 581), Op::Mul(582, 582), Op::AssertEq(vec![583], vec![582], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(189, 578), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::Add(586, 589), Op::Add(588, 591), Op::Add(590, 585), Op::Add(584, 587), Op::UnconstrainedU32Add3(vec![565, 566, 567, 568], vec![592, 593, 594, 595], vec![124, 125, 126, 127]), Op::U8RangeCheck(596, 597), Op::U8RangeCheck(598, 599), Op::Sub(600, 133), Op::Sub(600, 135), Op::Mul(601, 602), Op::Mul(600, 603), Op::AssertEq(vec![604], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(576, 596), Op::U8Xor(577, 597), Op::U8Xor(574, 598), Op::U8Xor(575, 599), Op::UnconstrainedU32Add(vec![578, 579, 580, 581], vec![606, 607, 608, 605]), Op::U8RangeCheck(609, 610), Op::U8RangeCheck(611, 612), Op::Mul(613, 613), Op::AssertEq(vec![614], vec![613], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(592, 609), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::Add(615, 618), Op::Add(617, 620), Op::Add(619, 622), Op::Add(621, 616)], ctrl: Ctrl::Return(0, vec![410, 411, 412, 413, 472, 473, 474, 475, 534, 535, 536, 537, 596, 597, 598, 599, 623, 624, 625, 626, 437, 438, 439, 440, 499, 500, 501, 502, 561, 562, 563, 564, 547, 548, 549, 550, 609, 610, 611, 612, 423, 424, 425, 426, 485, 486, 487, 488, 482, 483, 484, 481, 544, 545, 546, 543, 606, 607, 608, 605, 420, 421, 422, 419, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]) }, layout: FunctionLayout { input_size: 128, selectors: 1, auxiliaries: 369, lookups: 193 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_33() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(34, vec![121, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 106, 107, 108, 109, 110, 111, 106, 112, 113, 114, 115, 116, 117, 118, 119, 120, 96, 97, 98, 99, 100, 101, 102, 103, 104, 121, 121, 121, 105, 121, 121, 121, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], 32, false)], ctrl: Ctrl::Return(0, vec![122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153]) }, layout: FunctionLayout { input_size: 106, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_34() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(34, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_35() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(37, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(0, vec![20]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(37, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(1, vec![20]) }), (G::from_u64(2), Block { ops: vec![Op::Call(784, vec![9], 8, false), Op::Const(G::from_u64(2)), Op::Call(42, vec![9, 18], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 28], 1, false), Op::Call(37, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 29], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }), (G::from_u64(3), Block { ops: vec![Op::Call(784, vec![9], 8, false), Op::Const(G::from_u64(3)), Op::Call(42, vec![9, 18], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 28], 1, false), Op::Call(37, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 29], 1, false)], ctrl: Ctrl::Return(3, vec![30]) }), (G::from_u64(4), Block { ops: vec![Op::Load(18, 17), Op::Const(G::from_u64(4)), Op::Call(35, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 18], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 38], 1, false), Op::Call(37, vec![37, 9, 10, 11, 12, 13, 14, 15, 16, 39], 1, false)], ctrl: Ctrl::Return(4, vec![40]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(37, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(5, vec![20]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(37, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(6, vec![20]) }), (G::from_u64(7), Block { ops: vec![Op::Call(47, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Const(G::from_u64(7)), Op::Call(50, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(37, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 28], 1, false)], ctrl: Ctrl::Return(7, vec![29]) }), (G::from_u64(8), Block { ops: vec![Op::Call(48, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Const(G::from_u64(8)), Op::Call(51, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(37, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 28], 1, false)], ctrl: Ctrl::Return(8, vec![29]) }), (G::from_u64(9), Block { ops: vec![Op::Call(49, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Const(G::from_u64(9)), Op::Call(52, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(37, vec![27, 19, 20, 21, 22, 23, 24, 25, 26, 28], 1, false)], ctrl: Ctrl::Return(9, vec![29]) }), (G::from_u64(10), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 6), Op::Load(18, 7), Op::Load(18, 8)], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![73]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(11, vec![73]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(74, 73), Op::Add(1, 75), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(10)), Op::Call(35, vec![55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 18], 1, false), Op::Call(35, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 79], 1, false), Op::Call(35, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 80], 1, false), Op::Call(45, vec![3, 4, 5, 81], 1, false), Op::Call(37, vec![78, 76, 77, 77, 77, 77, 77, 77, 77, 82], 1, false)], ctrl: Ctrl::Return(12, vec![83]) })) }))) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(11)), Op::Call(37, vec![19, 1, 2, 3, 4, 5, 6, 7, 8, 18], 1, false)], ctrl: Ctrl::Return(13, vec![20]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 14, auxiliaries: 61, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_36() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(8, 11), Op::Call(36, vec![1, 2, 3, 4, 5, 6, 7, 10, 12, 9], 1, false), Op::Store(vec![10, 0, 13])], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_37() -> Function { + Function { body: Block { ops: vec![Op::Add(7, 8), Op::Add(6, 10), Op::Add(5, 11), Op::Add(4, 12), Op::Add(3, 13), Op::Add(2, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(8)), Op::U8LessThan(1, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(16)), Op::Mul(19, 0), Op::Add(20, 1), Op::Store(vec![18, 21, 9])], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(18, 0), Op::Const(G::from_u64(4)), Op::Call(40, vec![19, 20, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(16, 0), Op::Const(G::from_u64(4)), Op::Call(40, vec![17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(2, vec![19]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_38() -> Function { + Function { body: Block { ops: vec![Op::Add(7, 8), Op::Add(6, 10), Op::Add(5, 11), Op::Add(4, 12), Op::Add(3, 13), Op::Add(2, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(32)), Op::U8LessThan(1, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Mul(19, 0), Op::Add(20, 1), Op::Store(vec![18, 21, 9])], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(18, 0), Op::Const(G::from_u64(16)), Op::Call(40, vec![19, 20, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(16, 0), Op::Const(G::from_u64(16)), Op::Call(40, vec![17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(2, vec![19]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_39() -> Function { + Function { body: Block { ops: vec![Op::Add(6, 7), Op::Add(5, 9), Op::Add(4, 10), Op::Add(3, 11), Op::Add(2, 12), Op::Add(1, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(0, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 0, 8])], ctrl: Ctrl::Return(0, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Call(40, vec![17, 18, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(1, vec![19]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Call(40, vec![15, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(2, vec![17]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_40() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Const(G::from_u64(2)), Op::Mul(12, 1), Op::Sub(11, 13), Op::Const(G::from_u64(255)), Op::Sub(15, 1), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 14, 16, 15, 15, 15, 15, 15, 15], 9, false)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Const(G::from_u64(2)), Op::Mul(27, 1), Op::Sub(26, 28), Op::U8Add(2, 29), Op::Const(G::from_u64(1)), Op::Sub(31, 32), Op::Add(3, 33), Op::Const(G::from_u64(0)), Op::Add(28, 34), Op::Add(0, 36), Op::Store(vec![35, 30, 10]), Op::Store(vec![35, 37, 38])], ctrl: Ctrl::Return(0, vec![39]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Mul(26, 1), Op::Add(0, 27), Op::Const(G::from_u64(0)), Op::Call(41, vec![28, 29, 17, 18, 19, 20, 21, 22, 23, 24, 10], 1, false)], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 11, selectors: 2, auxiliaries: 13, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_41() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Add(8, 9), Op::Add(7, 11), Op::Add(6, 12), Op::Add(5, 13), Op::Add(4, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Call(36, vec![2, 3, 4, 5, 6, 7, 8, 9, 17, 10], 1, false), Op::Store(vec![16, 0, 18])], ctrl: Ctrl::Return(0, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(255)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 16, 16, 17, 17, 17, 17, 17, 17], 9, false), Op::Const(G::from_u64(1)), Op::Call(41, vec![0, 27, 18, 19, 20, 21, 22, 23, 24, 25, 10], 1, false)], ctrl: Ctrl::Return(1, vec![28]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Add(8, 9), Op::Add(7, 11), Op::Add(6, 12), Op::Add(5, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(0, 16), Op::Const(G::from_u64(3)), Op::Call(36, vec![2, 3, 4, 5, 6, 7, 8, 9, 18, 10], 1, false), Op::Store(vec![15, 17, 19])], ctrl: Ctrl::Return(2, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(255)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 15, 15, 15, 16, 16, 16, 16, 16], 9, false), Op::Const(G::from_u64(2)), Op::Call(41, vec![0, 26, 17, 18, 19, 20, 21, 22, 23, 24, 10], 1, false)], ctrl: Ctrl::Return(3, vec![27]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Add(8, 9), Op::Add(7, 11), Op::Add(6, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Add(0, 15), Op::Const(G::from_u64(4)), Op::Call(36, vec![2, 3, 4, 5, 6, 7, 8, 9, 17, 10], 1, false), Op::Store(vec![14, 16, 18])], ctrl: Ctrl::Return(4, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(255)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 14, 14, 14, 14, 15, 15, 15, 15], 9, false), Op::Const(G::from_u64(3)), Op::Call(41, vec![0, 25, 16, 17, 18, 19, 20, 21, 22, 23, 10], 1, false)], ctrl: Ctrl::Return(5, vec![26]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Add(0, 12), Op::Const(G::from_u64(8)), Op::Call(36, vec![2, 3, 4, 5, 6, 7, 8, 9, 14, 10], 1, false), Op::Store(vec![11, 13, 15])], ctrl: Ctrl::Return(6, vec![16]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 11, selectors: 7, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_42() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(42, vec![11, 1], 1, false), Op::Call(39, vec![3, 4, 5, 6, 7, 8, 9, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_43() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![2]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(4, 3), Op::Add(2, 5)], ctrl: Ctrl::Return(4, vec![6]) })) })) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_44() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(43, vec![1, 2], 1, false), Op::Mul(4, 5), Op::Add(3, 6)], ctrl: Ctrl::Return(4, vec![7]) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_45() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(44, vec![0, 1, 2], 1, false), Op::Store(vec![4, 5, 3])], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_46() -> Function { + Function { body: Block { ops: vec![Op::Call(44, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(16)), Op::Call(43, vec![3, 4], 1, false), Op::Mul(7, 8), Op::Add(6, 9), Op::Const(G::from_u64(0)), Op::Store(vec![11, 10, 5])], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_47() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Load(18, 1), Op::Call(47, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(16, vec![36, 37, 38, 39, 40, 41, 42, 43], 8, false)], ctrl: Ctrl::Return(0, vec![44, 45, 46, 47, 48, 49, 50, 51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 18, 18, 18, 18, 18, 18, 18]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_48() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Load(18, 5), Op::Call(48, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(16, vec![36, 37, 38, 39, 40, 41, 42, 43], 8, false)], ctrl: Ctrl::Return(0, vec![44, 45, 46, 47, 48, 49, 50, 51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 18, 18, 18, 18, 18, 18, 18]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_49() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(9), Block { ops: vec![Op::Load(18, 7), Op::Call(49, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(16, vec![36, 37, 38, 39, 40, 41, 42, 43], 8, false)], ctrl: Ctrl::Return(0, vec![44, 45, 46, 47, 48, 49, 50, 51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 18, 18, 18, 18, 18, 18, 18]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_50() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Load(18, 1), Op::Load(18, 2), Op::Call(35, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(50, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false)], ctrl: Ctrl::Return(0, vec![56]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(35, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 39, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_51() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Load(18, 4), Op::Load(18, 5), Op::Call(51, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(35, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false), Op::Call(45, vec![1, 2, 3, 56], 1, false)], ctrl: Ctrl::Return(0, vec![57]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(35, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_52() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(9), Block { ops: vec![Op::Load(18, 6), Op::Load(18, 7), Op::Call(52, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(35, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false), Op::Call(46, vec![1, 2, 3, 4, 5, 56], 1, false)], ctrl: Ctrl::Return(0, vec![57]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(35, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_53() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(0)), Op::Store(vec![34, 33, 1]), Op::Store(vec![34, 32, 35]), Op::Store(vec![34, 31, 36]), Op::Store(vec![34, 30, 37]), Op::Store(vec![34, 29, 38]), Op::Store(vec![34, 28, 39]), Op::Store(vec![34, 27, 40]), Op::Store(vec![34, 26, 41]), Op::Store(vec![34, 25, 42]), Op::Store(vec![34, 24, 43]), Op::Store(vec![34, 23, 44]), Op::Store(vec![34, 22, 45]), Op::Store(vec![34, 21, 46]), Op::Store(vec![34, 20, 47]), Op::Store(vec![34, 19, 48]), Op::Store(vec![34, 18, 49]), Op::Store(vec![34, 17, 50]), Op::Store(vec![34, 16, 51]), Op::Store(vec![34, 15, 52]), Op::Store(vec![34, 14, 53]), Op::Store(vec![34, 13, 54]), Op::Store(vec![34, 12, 55]), Op::Store(vec![34, 11, 56]), Op::Store(vec![34, 10, 57]), Op::Store(vec![34, 9, 58]), Op::Store(vec![34, 8, 59]), Op::Store(vec![34, 7, 60]), Op::Store(vec![34, 6, 61]), Op::Store(vec![34, 5, 62]), Op::Store(vec![34, 4, 63]), Op::Store(vec![34, 3, 64]), Op::Store(vec![34, 2, 65])], ctrl: Ctrl::Return(0, vec![66]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 65, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_54() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![2]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(3, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(4, vec![2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(5, vec![2]) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(6, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(9))], ctrl: Ctrl::Return(7, vec![2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(10))], ctrl: Ctrl::Return(8, vec![2]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_55() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Load(9, 1), Op::Call(55, vec![9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Call(16, vec![18, 19, 20, 21, 22, 23, 24, 25], 8, false)], ctrl: Ctrl::Return(0, vec![26, 27, 28, 29, 30, 31, 32, 33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9, 9, 9, 9, 9, 9, 9, 9]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 26, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_56() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Load(9, 1), Op::Call(56, vec![9, 10, 11, 12, 13, 14, 15, 16, 17], 9, false)], ctrl: Ctrl::Return(0, vec![18, 19, 20, 21, 22, 23, 24, 25, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 1, 2, 3, 4, 5, 6, 7, 8]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 19, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_57() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 9])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(55, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(56, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 9, false), Op::Const(G::from_u64(0)), Op::Call(57, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 9], 1, false), Op::Call(38, vec![27, 10, 11, 12, 13, 14, 15, 16, 17, 28], 1, false)], ctrl: Ctrl::Return(1, vec![29]) }), (G::from_u64(2), Block { ops: vec![Op::Load(9, 1), Op::Load(9, 2), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(57, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(57, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 30], 1, false), Op::Call(38, vec![28, 29, 29, 29, 29, 29, 29, 29, 29, 31], 1, false)], ctrl: Ctrl::Return(2, vec![32]) }), (G::from_u64(3), Block { ops: vec![Op::Load(9, 1), Op::Load(9, 2), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(57, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(57, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 30], 1, false), Op::Call(38, vec![28, 29, 29, 29, 29, 29, 29, 29, 29, 31], 1, false)], ctrl: Ctrl::Return(3, vec![32]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(38, vec![10, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 5, auxiliaries: 22, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_58() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(18, 3), Op::Call(58, vec![4, 1], 1, false), Op::Call(35, vec![5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 24, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_59() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(9, 3), Op::Call(59, vec![4, 1], 1, false), Op::Call(57, vec![5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![15]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_60() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(60, vec![4, 1], 1, false), Op::Call(53, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_61() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 1])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 1])], ctrl: Ctrl::Return(1, vec![4]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![2, 3, 1])], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Store(vec![2, 3, 1])], ctrl: Ctrl::Return(3, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_62() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 10), Op::Load(18, 11), Op::Call(54, vec![0, 1], 1, false), Op::Const(G::from_u64(0)), Op::Call(35, vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 12], 1, false), Op::Call(35, vec![13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 51], 1, false), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 52], 1, false), Op::Store(vec![50, 49, 53])], ctrl: Ctrl::Return(0, vec![54]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 42, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_63() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 8), Op::Call(35, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(39, vec![0, 1, 2, 3, 4, 5, 6, 7, 28], 1, false)], ctrl: Ctrl::Return(0, vec![29]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_64() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(64, vec![12, 1], 1, false), Op::Call(63, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_65() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 42), Op::Const(G::from_u64(2)), Op::Mul(63, 1), Op::Add(0, 64), Op::Call(796, vec![43], 8, false), Op::Const(G::from_u64(0)), Op::Call(64, vec![43, 44], 1, false), Op::Call(39, vec![66, 67, 68, 69, 70, 71, 72, 73, 75], 1, false), Op::Call(35, vec![45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 76], 1, false), Op::Call(39, vec![34, 35, 36, 37, 38, 39, 40, 41, 77], 1, false), Op::Call(39, vec![26, 27, 28, 29, 30, 31, 32, 33, 78], 1, false), Op::Call(39, vec![18, 19, 20, 21, 22, 23, 24, 25, 79], 1, false), Op::Call(39, vec![10, 11, 12, 13, 14, 15, 16, 17, 80], 1, false), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 81], 1, false), Op::Store(vec![74, 65, 82])], ctrl: Ctrl::Return(0, vec![83]) }))) }, layout: FunctionLayout { input_size: 45, selectors: 1, auxiliaries: 36, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_66() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 9), Op::Const(G::from_u64(0)), Op::Call(35, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 30], 1, false), Op::Store(vec![29, 0, 31])], ctrl: Ctrl::Return(0, vec![32]) }))) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_67() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 9), Op::Call(35, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 29], 1, false), Op::Call(61, vec![0, 30], 1, false)], ctrl: Ctrl::Return(0, vec![31]) }))) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_68() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 33), Op::Const(G::from_u64(0)), Op::Call(35, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 34], 1, false), Op::Call(39, vec![25, 26, 27, 28, 29, 30, 31, 32, 54], 1, false), Op::Call(39, vec![17, 18, 19, 20, 21, 22, 23, 24, 55], 1, false), Op::Call(39, vec![9, 10, 11, 12, 13, 14, 15, 16, 56], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 57], 1, false), Op::Store(vec![53, 0, 58])], ctrl: Ctrl::Return(0, vec![59]) }))) }, layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 25, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_69() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(69, vec![37, 1], 1, false), Op::Call(68, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38], 1, false)], ctrl: Ctrl::Return(1, vec![39]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 39, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_70() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(18, 25), Op::Call(791, vec![26], 8, false), Op::Const(G::from_u64(0)), Op::Call(69, vec![26, 27], 1, false), Op::Call(39, vec![46, 47, 48, 49, 50, 51, 52, 53, 55], 1, false), Op::Call(35, vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 56], 1, false), Op::Call(39, vec![17, 18, 19, 20, 21, 22, 23, 24, 57], 1, false), Op::Call(39, vec![9, 10, 11, 12, 13, 14, 15, 16, 58], 1, false), Op::Call(39, vec![1, 2, 3, 4, 5, 6, 7, 8, 59], 1, false), Op::Store(vec![54, 0, 60])], ctrl: Ctrl::Return(0, vec![61]) }))) }, layout: FunctionLayout { input_size: 28, selectors: 1, auxiliaries: 34, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_71() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(53, vec![8, 9], 1, false), Op::Call(39, vec![0, 1, 2, 3, 4, 5, 6, 7, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_72() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(53, vec![16, 17], 1, false), Op::Call(39, vec![8, 9, 10, 11, 12, 13, 14, 15, 18], 1, false), Op::Call(39, vec![0, 1, 2, 3, 4, 5, 6, 7, 19], 1, false)], ctrl: Ctrl::Return(0, vec![20]) }))) }, layout: FunctionLayout { input_size: 18, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_73() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(62, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 45], 1, false), Op::Store(vec![46, 46, 47])], ctrl: Ctrl::Return(0, vec![48]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(70, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 45], 1, false), Op::Store(vec![46, 47, 48])], ctrl: Ctrl::Return(1, vec![49]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Call(65, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45], 1, false), Op::Store(vec![46, 47, 48])], ctrl: Ctrl::Return(2, vec![49]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 46, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_74() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(74, vec![48, 1], 1, false), Op::Call(73, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49], 1, false)], ctrl: Ctrl::Return(1, vec![50]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_75() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(62, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 45], 1, false)], ctrl: Ctrl::Return(0, vec![46]) }), (G::from_u64(1), Block { ops: vec![Op::Call(65, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45], 1, false)], ctrl: Ctrl::Return(1, vec![46]) }), (G::from_u64(2), Block { ops: vec![Op::Call(66, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 45], 1, false)], ctrl: Ctrl::Return(2, vec![46]) }), (G::from_u64(3), Block { ops: vec![Op::Call(67, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 45], 1, false)], ctrl: Ctrl::Return(3, vec![46]) }), (G::from_u64(4), Block { ops: vec![Op::Call(72, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 45], 1, false)], ctrl: Ctrl::Return(4, vec![46]) }), (G::from_u64(5), Block { ops: vec![Op::Call(71, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 45], 1, false)], ctrl: Ctrl::Return(5, vec![46]) }), (G::from_u64(6), Block { ops: vec![Op::Call(71, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 45], 1, false)], ctrl: Ctrl::Return(6, vec![46]) }), (G::from_u64(7), Block { ops: vec![Op::Call(71, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 45], 1, false)], ctrl: Ctrl::Return(7, vec![46]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 46, selectors: 8, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_76() -> Function { + Function { body: Block { ops: vec![Op::Call(786, vec![0], 8, false), Op::Call(58, vec![0, 1], 1, false), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_77() -> Function { + Function { body: Block { ops: vec![Op::Call(786, vec![0], 8, false), Op::Call(60, vec![0, 1], 1, false), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_78() -> Function { + Function { body: Block { ops: vec![Op::Call(786, vec![0], 8, false), Op::Call(59, vec![0, 1], 1, false), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_79() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(78, vec![47, 48], 1, false), Op::Call(77, vec![46, 49], 1, false), Op::Call(76, vec![45, 50], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Call(795, vec![1], 8, false), Op::Const(G::from_u64(12)), Op::Call(74, vec![1, 51], 1, false), Op::Call(37, vec![60, 52, 53, 54, 55, 56, 57, 58, 59, 61], 1, false)], ctrl: Ctrl::Return(0, vec![62]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 53, 53, 53, 53, 53, 53, 53, 54], 1, false)], ctrl: Ctrl::Return(1, vec![55]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(2, vec![56]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(3, vec![56]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(4, vec![56]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(5, vec![56]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(6, vec![56]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(7, vec![56]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(13)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Call(75, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 51], 1, false), Op::Call(37, vec![52, 53, 54, 54, 54, 54, 54, 54, 54, 55], 1, false)], ctrl: Ctrl::Return(8, vec![56]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 49, selectors: 9, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_80() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_81() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2, 2, 2, 2, 2, 2, 2, 2, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Call(81, vec![4, 6], 9, false)], ctrl: Ctrl::Return(1, vec![3, 7, 8, 9, 10, 11, 12, 13, 15]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_82() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::U8BitDecomposition(2), Op::Const(G::from_u64(2)), Op::Mul(12, 9), Op::Const(G::from_u64(4)), Op::Mul(14, 10), Op::Const(G::from_u64(8)), Op::Mul(16, 11), Op::Add(15, 17), Op::Add(13, 18), Op::Add(8, 19), Op::Mul(12, 5), Op::Mul(14, 6), Op::Add(21, 22), Op::Add(4, 23)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![20, 24, 25, 25, 25, 25, 25, 25, 25, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(85, vec![24, 25, 3], 9, false)], ctrl: Ctrl::Return(1, vec![20, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_83() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::U8BitDecomposition(2), Op::Const(G::from_u64(2)), Op::Mul(12, 11), Op::Add(10, 13), Op::Mul(12, 5), Op::Const(G::from_u64(4)), Op::Mul(16, 6), Op::Const(G::from_u64(8)), Op::Mul(18, 7), Op::Const(G::from_u64(16)), Op::Mul(20, 8), Op::Add(19, 21), Op::Add(17, 22), Op::Add(15, 23), Op::Add(4, 24)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![14, 25, 26, 26, 26, 26, 26, 26, 26, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(16)), Op::Call(85, vec![25, 26, 3], 9, false)], ctrl: Ctrl::Return(1, vec![14, 27, 28, 29, 30, 31, 32, 33, 34, 35]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_84() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(2, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2, 6, 6, 6, 6, 6, 6, 6, 3]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Sub(2, 6), Op::Const(G::from_u64(64)), Op::Call(85, vec![7, 8, 3], 9, false)], ctrl: Ctrl::Return(1, vec![9, 10, 11, 12, 13, 14, 15, 16, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_85() -> Function { + Function { body: Block { ops: vec![Op::U8LessThan(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(7, 1), Op::U8Add(5, 8), Op::Add(0, 10), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 11, 12, 12, 12, 12, 12, 12, 6]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Sub(0, 1), Op::Call(86, vec![4, 1, 2], 9, false)], ctrl: Ctrl::Return(1, vec![5, 6, 7, 8, 9, 10, 11, 12, 13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_86() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(3, 1)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(81, vec![2, 5], 9, false), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 15, 15, 15, 15, 15], 9, false)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23, 14]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(81, vec![2, 5], 9, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 16, 16, 16, 16, 16], 9, false)], ctrl: Ctrl::Return(1, vec![17, 18, 19, 20, 21, 22, 23, 24, 14]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(81, vec![2, 5], 9, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 15, 16, 16, 16, 16], 9, false)], ctrl: Ctrl::Return(2, vec![17, 18, 19, 20, 21, 22, 23, 24, 14]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(81, vec![2, 5], 9, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 15, 15, 16, 16, 16], 9, false), Op::AssertEq(vec![25], vec![16], Some("TagN value exceeds UInt64".into()))], ctrl: Ctrl::Return(3, vec![17, 18, 19, 20, 21, 22, 23, 24, 14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 19, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_87() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(87, vec![18, 19, 20, 21, 22, 23, 24, 25, 26], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![29, 10, 11, 12, 13, 14, 15, 16, 17, 27])], ctrl: Ctrl::Return(1, vec![30, 28]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 22, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_88() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(95, vec![1], 2, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 0, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14]), Op::Call(17, vec![2, 3, 4, 5, 6, 7, 8, 9], 8, false), Op::Call(88, vec![15, 12, 16, 17, 18, 19, 20, 21, 22, 23], 2, false)], ctrl: Ctrl::Return(1, vec![24, 25]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_89() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![2]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![2, 3]) })) })) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_90() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(4, 1), Op::Add(0, 5)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(2, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(3, vec![7]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Call(89, vec![2, 3], 2, false)], ctrl: Ctrl::Return(4, vec![7, 8, 9]) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_91() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::U8BitDecomposition(1), Op::Add(9, 10), Op::Add(8, 11), Op::Add(7, 12), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], Some("reserved binder contract bits".into())), Op::Call(90, vec![3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(0, vec![15, 16, 17, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_92() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::U8BitDecomposition(1), Op::Add(9, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("reserved forall contract bits".into())), Op::Call(90, vec![3, 4, 5, 6], 3, false), Op::Call(89, vec![7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![13, 14, 15, 16, 17, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_93() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(95, vec![0], 2, false), Op::Load(18, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![30], vec![31], Some("non-canonical lambda telescope".into()))], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10, 11]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(91, vec![0], 4, false), Op::Call(95, vec![13], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(93, vec![15, 16, 17, 18, 19, 20, 21, 22, 23], 2, false), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 10, 11, 12, 14, 24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27])], ctrl: Ctrl::Return(2, vec![28, 25]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 23, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_94() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(95, vec![0], 2, false), Op::Load(18, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![30], vec![31], Some("non-canonical forall telescope".into()))], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10, 11]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(92, vec![0], 6, false), Op::Call(95, vec![15], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(94, vec![17, 18, 19, 20, 21, 22, 23, 24, 25], 2, false), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(0)), Op::Store(vec![28, 10, 11, 12, 13, 14, 16, 26, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29])], ctrl: Ctrl::Return(2, vec![30, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 23, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_95() -> Function { + Function { body: Block { ops: vec![Op::Call(82, vec![0], 10, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![12, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![13, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(84, vec![10], 9, false), Op::Call(87, vec![19, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![22, 11, 12, 13, 14, 15, 16, 17, 18, 20, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(2, vec![24, 21]) }), (G::from_u64(3), Block { ops: vec![Op::Call(84, vec![10], 9, false), Op::Call(87, vec![19, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![22, 11, 12, 13, 14, 15, 16, 17, 18, 20, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(3, vec![24, 21]) }), (G::from_u64(4), Block { ops: vec![Op::Call(84, vec![10], 9, false), Op::Call(95, vec![19], 2, false), Op::Const(G::from_u64(4)), Op::Store(vec![22, 11, 12, 13, 14, 15, 16, 17, 18, 2, 3, 4, 5, 6, 7, 8, 9, 20])], ctrl: Ctrl::Return(4, vec![23, 21]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(5, vec![13, 10]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(6, vec![13, 10]) }), (G::from_u64(7), Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("App with zero arguments".into())), Op::Call(95, vec![10], 2, false), Op::Load(18, 13)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![33], vec![34], Some("non-canonical application telescope".into())), Op::Call(88, vec![13, 14, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(7, vec![35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(88, vec![13, 14, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(8, vec![33, 34]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("Lam with zero binders".into())), Op::Call(93, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(9, vec![13, 14]) }), (G::from_u64(9), Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("All with zero binders".into())), Op::Call(94, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(10, vec![13, 14]) }), (G::from_u64(10), Block { ops: vec![Op::Call(96, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false)], ctrl: Ctrl::Return(11, vec![11, 12]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(11)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(12, vec![13, 10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_96() -> Function { + Function { body: Block { ops: vec![Op::Add(7, 8), Op::Add(6, 9), Op::Add(5, 10), Op::Add(4, 11), Op::Add(3, 12), Op::Add(2, 13), Op::Const(G::from_u64(0)), Op::AssertEq(vec![14], vec![15], Some("oversized let flags".into())), Op::Const(G::from_u64(4)), Op::U8LessThan(1, 16), Op::Const(G::from_u64(1)), Op::AssertEq(vec![17], vec![18], Some("reserved let flags".into())), Op::U8BitDecomposition(1)], ctrl: Ctrl::MatchContinue(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![27]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![27]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Call(91, vec![0], 4, false), Op::Call(95, vec![31], 2, false), Op::Call(95, vec![33], 2, false), Op::Call(95, vec![35], 2, false), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(0)), Op::Store(vec![38, 19, 27, 28, 29, 30, 32, 34, 36, 39, 39, 39, 39, 39, 39, 39, 39, 39])], ctrl: Ctrl::Return(2, vec![40, 37]) })) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 22, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_97() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 2, 3, 4, 5, 6, 7, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(17, vec![9, 10, 11, 12, 13, 14, 15, 16], 8, false), Op::Call(97, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 18, 19, 20, 21, 22, 23, 24, 25], 9, false), Op::Const(G::from_u64(1)), Op::Store(vec![26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![35, 36, 37, 37, 37, 37, 37, 37, 37]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 2, auxiliaries: 20, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_98() -> Function { + Function { body: Block { ops: vec![Op::Call(83, vec![0], 10, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(98, vec![10], 10, false), Op::Call(97, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 2, 3, 4, 5, 6, 7, 8, 9], 9, false)], ctrl: Ctrl::Return(1, vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 21]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Call(98, vec![10], 10, false), Op::Call(98, vec![20], 10, false), Op::Const(G::from_u64(2)), Op::Store(vec![11, 12, 13, 14, 15, 16, 17, 18, 19]), Op::Store(vec![21, 22, 23, 24, 25, 26, 27, 28, 29]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![31, 32, 33, 34, 34, 34, 34, 34, 34, 30]) }), (G::from_u64(2), Block { ops: vec![Op::Call(98, vec![10], 10, false), Op::Call(98, vec![20], 10, false), Op::Const(G::from_u64(3)), Op::Store(vec![11, 12, 13, 14, 15, 16, 17, 18, 19]), Op::Store(vec![21, 22, 23, 24, 25, 26, 27, 28, 29]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![31, 32, 33, 34, 34, 34, 34, 34, 34, 30]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 33, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_99() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Store(vec![2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86, 89, 92, 95])], ctrl: Ctrl::Return(0, vec![97, 96]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_100() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(95, vec![0], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(100, vec![11, 12, 13, 14, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![22, 10, 20])], ctrl: Ctrl::Return(1, vec![23, 21]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_101() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(98, vec![0], 10, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(101, vec![19, 20, 21, 22, 23, 24, 25, 26, 27], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12, 13, 14, 15, 16, 17, 18]), Op::Store(vec![30, 31, 28])], ctrl: Ctrl::Return(1, vec![32, 29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_102() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(99, vec![0], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(102, vec![11, 12, 13, 14, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![22, 10, 20])], ctrl: Ctrl::Return(1, vec![23, 21]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_103() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(100, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_104() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(102, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_105() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(101, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_106() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1, 2]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1, 2]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![1, 2]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1, 1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(5, vec![1, 2]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![1, 2]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1, 2]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(8, vec![1, 1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_107() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(106, vec![1], 2, false), Op::Call(84, vec![2], 9, false), Op::Call(95, vec![13], 2, false), Op::Call(95, vec![15], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 17]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_108() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(95, vec![9], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_109() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(95, vec![18], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(109, vec![20, 21, 22, 23, 24, 25, 26, 27, 28], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![31, 10, 11, 12, 13, 14, 15, 16, 17, 19, 29])], ctrl: Ctrl::Return(1, vec![32, 30]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_110() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Const(G::from_u64(4)), Op::U8LessThan(1, 3), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], Some("invalid recursor flags".into())), Op::U8BitDecomposition(1), Op::Call(84, vec![2], 9, false), Op::Call(84, vec![22], 9, false), Op::Call(84, vec![31], 9, false), Op::Call(84, vec![40], 9, false), Op::Call(84, vec![49], 9, false), Op::Call(95, vec![58], 2, false), Op::Call(84, vec![60], 9, false), Op::Call(109, vec![69, 61, 62, 63, 64, 65, 66, 67, 68], 2, false)], ctrl: Ctrl::Return(0, vec![6, 7, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 55, 56, 57, 59, 70, 71]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 70, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_111() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U8LessThan(0, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("Bool byte is not 0 or 1".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_112() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(111, vec![1], 0, false), Op::Call(84, vec![2], 9, false), Op::Call(95, vec![11], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_113() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(3, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_114() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(113, vec![1], 1, false), Op::Call(84, vec![2], 9, false), Op::Call(95, vec![12], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_115() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(111, vec![1], 0, false), Op::Call(84, vec![2], 9, false), Op::Call(84, vec![11], 9, false), Op::Call(84, vec![20], 9, false), Op::Call(84, vec![29], 9, false), Op::Call(95, vec![38], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_116() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(115, vec![0], 35, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(116, vec![44, 45, 46, 47, 48, 49, 50, 51, 52], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![55, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 53])], ctrl: Ctrl::Return(1, vec![56, 54]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 48, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_117() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(111, vec![1], 0, false), Op::U8BitDecomposition(1), Op::Call(84, vec![2], 9, false), Op::Call(84, vec![19], 9, false), Op::Call(84, vec![28], 9, false), Op::Call(95, vec![37], 2, false), Op::Call(84, vec![39], 9, false), Op::Call(116, vec![48, 40, 41, 42, 43, 44, 45, 46, 47], 2, false)], ctrl: Ctrl::Return(0, vec![3, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 38, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_118() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(99, vec![9], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_119() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(84, vec![9], 9, false), Op::Call(99, vec![18], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_120() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(107, vec![2], 13, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![16, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Call(117, vec![2], 28, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![31, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 30]) }), (G::from_u64(2), Block { ops: vec![Op::Call(110, vec![2], 45, false), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![48, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 48, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_121() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(120, vec![0], 46, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(121, vec![55, 56, 57, 58, 59, 60, 61, 62, 63], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![66, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 64])], ctrl: Ctrl::Return(1, vec![67, 65]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 59, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_122() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(107, vec![1], 13, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 14]) }), (G::from_u64(1), Block { ops: vec![Op::Call(110, vec![1], 45, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![47, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46]) }), (G::from_u64(2), Block { ops: vec![Op::Call(112, vec![1], 11, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![13, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12]) }), (G::from_u64(3), Block { ops: vec![Op::Call(114, vec![1], 11, false), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![13, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12]) }), (G::from_u64(4), Block { ops: vec![Op::Call(119, vec![1], 18, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 19]) }), (G::from_u64(5), Block { ops: vec![Op::Call(118, vec![1], 10, false), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) }), (G::from_u64(6), Block { ops: vec![Op::Call(118, vec![1], 10, false), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) }), (G::from_u64(7), Block { ops: vec![Op::Call(118, vec![1], 10, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![12, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 8, auxiliaries: 46, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_123() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(12), Block { ops: vec![Op::Call(121, vec![9, 1, 2, 3, 4, 5, 6, 7, 8], 2, false), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11]) }), (G::from_u64(13), Block { ops: vec![Op::Add(2, 3), Op::Add(10, 4), Op::Add(11, 5), Op::Add(12, 6), Op::Add(13, 7), Op::Add(14, 8), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], Some("constant info: TagN size exceeds a single byte".into())), Op::Call(122, vec![1, 9], 46, false)], ctrl: Ctrl::Return(1, vec![17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 47, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_124() -> Function { + Function { body: Block { ops: vec![Op::Call(82, vec![0], 10, false)], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(12), Block { ops: vec![Op::Call(121, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![13, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12]) }), (G::from_u64(13), Block { ops: vec![Op::Add(3, 4), Op::Add(11, 5), Op::Add(12, 6), Op::Add(13, 7), Op::Add(14, 8), Op::Add(15, 9), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], Some("constant info: TagN size exceeds a single byte".into())), Op::Call(122, vec![2, 10], 46, false)], ctrl: Ctrl::Yield(1, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]) })].into_iter().collect(), None, 46, 46, 1, Box::new(Block { ops: vec![Op::Call(84, vec![56], 9, false), Op::Call(100, vec![65, 57, 58, 59, 60, 61, 62, 63, 64], 2, false), Op::Call(84, vec![67], 9, false), Op::Call(102, vec![76, 68, 69, 70, 71, 72, 73, 74, 75], 2, false), Op::Call(84, vec![78], 9, false), Op::Call(101, vec![87, 79, 80, 81, 82, 83, 84, 85, 86], 2, false)], ctrl: Ctrl::Return(2, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 66, 77, 88, 89]) })) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 136, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_125() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Call(125, vec![2], 2, false), Op::Call(783, vec![6, 3], 1, false)], ctrl: Ctrl::Return(0, vec![5, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![0, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_126() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12]), Op::Store(vec![11, 12, 11, 11, 11, 11, 11, 11, 11, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 12, 12, 12, 12, 12, 12], 9, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![22, 13, 14, 15, 16, 17, 18, 19, 20, 10])], ctrl: Ctrl::Return(1, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(126, vec![10], 1, false), Op::Store(vec![22, 13, 14, 15, 16, 17, 18, 19, 20, 23])], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_127() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(126, vec![1], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(126, vec![0], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(15, vec![4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21], 9, false), Op::Const(G::from_u64(0)), Op::Call(15, vec![23, 24, 25, 26, 27, 28, 29, 30, 2, 32, 32, 32, 32, 32, 32, 32], 9, false), Op::Add(31, 41), Op::Call(127, vec![12, 22, 42], 1, false), Op::Store(vec![32, 33, 34, 35, 36, 37, 38, 39, 40, 43])], ctrl: Ctrl::Return(4, vec![44]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 41, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_128() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(127, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_129() -> Function { + Function { body: Block { ops: vec![Op::U8Sub(0, 8), Op::U8Sub(1, 9), Op::U8Sub(18, 17), Op::Add(19, 21), Op::U8Sub(2, 10), Op::U8Sub(23, 22), Op::Add(24, 26), Op::U8Sub(3, 11), Op::U8Sub(28, 27), Op::Add(29, 31), Op::U8Sub(4, 12), Op::U8Sub(33, 32), Op::Add(34, 36), Op::U8Sub(5, 13), Op::U8Sub(38, 37), Op::Add(39, 41), Op::U8Sub(6, 14), Op::U8Sub(43, 42), Op::Add(44, 46), Op::U8Sub(7, 15), Op::U8Sub(48, 47), Op::Add(49, 51)], ctrl: Ctrl::Return(0, vec![16, 20, 25, 30, 35, 40, 45, 50, 52]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_130() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(0, vec![24, 2]) }), (G::from_u64(0), Block { ops: vec![Op::Call(144, vec![1], 1, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24, 24, 24, 24, 24, 24, 24, 24])], ctrl: Ctrl::Return(1, vec![25, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24, 24, 24, 24, 24, 24, 24, 24])], ctrl: Ctrl::Return(2, vec![25, 24]) }))) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![0, 23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(129, vec![4, 5, 6, 7, 8, 9, 10, 11, 23, 24, 24, 24, 24, 24, 24, 24], 9, false), Op::Store(vec![23, 23, 23, 23, 23, 23, 23, 23, 23, 23]), Op::Call(130, vec![12, 34, 33], 2, false), Op::Store(vec![24, 25, 26, 27, 28, 29, 30, 31, 32, 35])], ctrl: Ctrl::Return(4, vec![37, 36]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(129, vec![4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21], 9, false), Op::Const(G::from_u64(0)), Op::Call(129, vec![23, 24, 25, 26, 27, 28, 29, 30, 2, 32, 32, 32, 32, 32, 32, 32], 9, false), Op::Add(31, 41), Op::Call(130, vec![12, 22, 42], 2, false), Op::Store(vec![32, 33, 34, 35, 36, 37, 38, 39, 40, 43])], ctrl: Ctrl::Return(5, vec![45, 44]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 42, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_131() -> Function { + Function { body: Block { ops: vec![Op::Call(132, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_132() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 13]) }), (G::from_u64(0), Block { ops: vec![Op::U8RangeCheck(2, 3), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::Call(132, vec![10], 2, false), Op::Call(3, vec![12], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 2, 3, 4, 5, 6, 7, 8, 9, 11])], ctrl: Ctrl::Return(1, vec![15, 13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_133() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(133, vec![10], 1, false), Op::Load(10, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23, 23, 23, 23, 23, 23, 23, 23])], ctrl: Ctrl::Return(1, vec![24]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24, 24, 24, 24, 24, 24, 24, 24]), Op::Store(vec![23, 2, 3, 4, 5, 6, 7, 8, 9, 25])], ctrl: Ctrl::Return(2, vec![26]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![22, 2, 3, 4, 5, 6, 7, 8, 9, 11])], ctrl: Ctrl::Return(3, vec![23]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_134() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(130, vec![0, 1, 2], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(133, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_135() -> Function { + Function { body: Block { ops: vec![Op::Call(134, vec![0, 1], 1, false), Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_136() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![1, 2, 1, 1, 1, 1, 1, 1, 1, 3]), Op::Call(134, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_137() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::U32LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Sub(0, 4), Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(137, vec![5, 7], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_138() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 1), Op::Add(0, 17), Op::Mul(16, 9), Op::Add(8, 19), Op::Mul(16, 3), Op::Add(2, 21), Op::Mul(16, 11), Op::Add(10, 23), Op::Mul(16, 5), Op::Add(4, 25), Op::Mul(16, 13), Op::Add(12, 27), Op::Mul(16, 7), Op::Add(6, 29), Op::Mul(16, 15), Op::Add(14, 31), Op::Mul(18, 20), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(34, 35), Op::U8RangeCheck(36, 37), Op::Const(G::from_u64(0)), Op::U8RangeCheck(38, 42), Op::Mul(16, 35), Op::Const(G::from_u64(65536)), Op::Mul(16, 37), Op::Mul(44, 38), Op::Add(45, 46), Op::Add(36, 47), Op::Mul(44, 48), Op::Add(43, 49), Op::Add(34, 50), Op::AssertEq(vec![33], vec![51], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 24), Op::Mul(22, 20), Op::Add(53, 48), Op::Add(52, 54), Op::UnconstrainedGToBytes(55), Op::U8RangeCheck(56, 57), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 42), Op::Mul(16, 57), Op::Mul(16, 59), Op::Mul(44, 60), Op::Add(65, 66), Op::Add(58, 67), Op::Mul(44, 68), Op::Add(64, 69), Op::Add(56, 70), Op::AssertEq(vec![55], vec![71], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 28), Op::Mul(22, 24), Op::Mul(26, 20), Op::Add(74, 68), Op::Add(73, 75), Op::Add(72, 76), Op::UnconstrainedGToBytes(77), Op::U8RangeCheck(78, 79), Op::U8RangeCheck(80, 81), Op::U8RangeCheck(82, 42), Op::Mul(16, 79), Op::Mul(16, 81), Op::Mul(44, 82), Op::Add(87, 88), Op::Add(80, 89), Op::Mul(44, 90), Op::Add(86, 91), Op::Add(78, 92), Op::AssertEq(vec![77], vec![93], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 32), Op::Mul(22, 28), Op::Mul(26, 24), Op::Mul(30, 20), Op::Add(97, 90), Op::Add(96, 98), Op::Add(95, 99), Op::Add(94, 100), Op::UnconstrainedGToBytes(101), Op::U8RangeCheck(102, 103), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 42), Op::Mul(16, 103), Op::Mul(16, 105), Op::Mul(44, 106), Op::Add(111, 112), Op::Add(104, 113), Op::Mul(44, 114), Op::Add(110, 115), Op::Add(102, 116), Op::AssertEq(vec![101], vec![117], Some("u64_mul: column hint does not recompose".into())), Op::Mul(22, 32), Op::Mul(26, 28), Op::Mul(30, 24), Op::Add(120, 114), Op::Add(119, 121), Op::Add(118, 122), Op::UnconstrainedGToBytes(123), Op::U8RangeCheck(124, 125), Op::U8RangeCheck(126, 127), Op::U8RangeCheck(128, 42), Op::Mul(16, 125), Op::Mul(16, 127), Op::Mul(44, 128), Op::Add(133, 134), Op::Add(126, 135), Op::Mul(44, 136), Op::Add(132, 137), Op::Add(124, 138), Op::AssertEq(vec![123], vec![139], Some("u64_mul: column hint does not recompose".into())), Op::Mul(26, 32), Op::Mul(30, 28), Op::Add(141, 136), Op::Add(140, 142), Op::UnconstrainedGToBytes(143), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::U8RangeCheck(148, 42), Op::Mul(16, 145), Op::Mul(16, 147), Op::Mul(44, 148), Op::Add(153, 154), Op::Add(146, 155), Op::Mul(44, 156), Op::Add(152, 157), Op::Add(144, 158), Op::AssertEq(vec![143], vec![159], Some("u64_mul: column hint does not recompose".into())), Op::Mul(30, 32), Op::Add(160, 156), Op::UnconstrainedGToBytes(161), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::U8RangeCheck(166, 42), Op::Mul(16, 163), Op::Mul(16, 165), Op::Mul(44, 166), Op::Add(171, 172), Op::Add(164, 173), Op::Mul(44, 174), Op::Add(170, 175), Op::Add(162, 176), Op::AssertEq(vec![161], vec![177], Some("u64_mul: column hint does not recompose".into())), Op::AssertEq(vec![166], vec![42], Some("u64_mul: final carry exceeds one radix digit".into()))], ctrl: Ctrl::Return(0, vec![34, 35, 56, 57, 78, 79, 102, 103, 124, 125, 144, 145, 162, 163, 164, 165]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_139() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::Const(G::from_u64(0)), Op::U8RangeCheck(5, 9), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Const(G::from_u64(65536)), Op::Mul(10, 4), Op::Mul(12, 5), Op::Add(13, 14), Op::Add(3, 15), Op::Mul(12, 16), Op::Add(11, 17), Op::Add(1, 18), Op::AssertEq(vec![0], vec![19], Some("u64_mul: column hint does not recompose".into()))], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_140() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Const(G::from_u64(0)), Op::Call(141, vec![0, 1, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_141() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(142, vec![5, 6, 7, 8, 9, 10, 11, 12, 1, 14, 14, 14, 14, 14, 14, 14, 14], 1, false), Op::Call(143, vec![15, 3], 1, false), Op::Call(128, vec![2, 16], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 18), Op::Call(141, vec![13, 1, 17, 19], 1, false)], ctrl: Ctrl::Return(1, vec![20]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_142() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 8)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Call(6, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28])], ctrl: Ctrl::Return(0, vec![29]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29, 29, 29, 29, 29, 29, 29, 29]), Op::Store(vec![28, 9, 10, 11, 12, 13, 14, 15, 16, 30])], ctrl: Ctrl::Return(1, vec![31]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Call(138, vec![0, 1, 2, 3, 4, 5, 6, 7, 18, 19, 20, 21, 22, 23, 24, 25], 16, false), Op::Call(15, vec![27, 28, 29, 30, 31, 32, 33, 34, 9, 10, 11, 12, 13, 14, 15, 16], 9, false)], ctrl: Ctrl::Match(51, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(142, vec![0, 1, 2, 3, 4, 5, 6, 7, 26, 35, 36, 37, 38, 39, 40, 41, 42], 1, false), Op::Store(vec![52, 43, 44, 45, 46, 47, 48, 49, 50, 53])], ctrl: Ctrl::Return(2, vec![54]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(16, vec![35, 36, 37, 38, 39, 40, 41, 42], 8, false), Op::Call(142, vec![0, 1, 2, 3, 4, 5, 6, 7, 26, 53, 54, 55, 56, 57, 58, 59, 60], 1, false), Op::Store(vec![52, 43, 44, 45, 46, 47, 48, 49, 50, 61])], ctrl: Ctrl::Return(3, vec![62]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_143() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(143, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_144() -> Function { + Function { body: Block { ops: vec![Op::Call(133, vec![0], 1, false), Op::Load(10, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_145() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedBigUintDivMod(0, 1), Op::Call(131, vec![2], 1, false), Op::Call(133, vec![4], 1, false), Op::Call(131, vec![3], 1, false), Op::Call(133, vec![6], 1, false), Op::Call(140, vec![5, 1], 1, false), Op::Call(128, vec![8, 7], 1, false), Op::Call(133, vec![9], 1, false), Op::Call(133, vec![0], 1, false), Op::AssertEq(vec![10], vec![11], Some("div/mod hint: q*b + r != a".into())), Op::Call(144, vec![1], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(144, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("div/mod hint: division by zero must yield a zero quotient".into()))], ctrl: Ctrl::Return(0, vec![5, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(126, vec![7], 1, false), Op::Call(135, vec![13, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], Some("div/mod hint: remainder is not less than the divisor".into()))], ctrl: Ctrl::Return(1, vec![5, 7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_146() -> Function { + Function { body: Block { ops: vec![Op::Call(145, vec![0, 1], 2, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_147() -> Function { + Function { body: Block { ops: vec![Op::Call(145, vec![0, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_148() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(147, vec![0, 1], 1, false), Op::Call(148, vec![1, 3], 1, false)], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_149() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4, 4, 4, 4]), Op::Store(vec![3, 4, 3, 3, 3, 3, 3, 3, 3, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]), Op::Store(vec![3, 4, 3, 3, 3, 3, 3, 3, 3, 6]), Op::Call(145, vec![1, 7], 2, false), Op::Call(140, vec![0, 0], 1, false), Op::Call(133, vec![10], 1, false), Op::Call(133, vec![8], 1, false), Op::Call(149, vec![11, 12], 1, false), Op::Call(144, vec![9], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Call(140, vec![0, 13], 1, false)], ctrl: Ctrl::Return(2, vec![15]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 12, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_150() -> Function { + Function { body: Block { ops: vec![Op::U8And(0, 8), Op::U8And(1, 9), Op::U8And(2, 10), Op::U8And(3, 11), Op::U8And(4, 12), Op::U8And(5, 13), Op::U8And(6, 14), Op::U8And(7, 15)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_151() -> Function { + Function { body: Block { ops: vec![Op::U8Or(0, 8), Op::U8Or(1, 9), Op::U8Or(2, 10), Op::U8Or(3, 11), Op::U8Or(4, 12), Op::U8Or(5, 13), Op::U8Or(6, 14), Op::U8Or(7, 15)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_152() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 8), Op::U8Xor(1, 9), Op::U8Xor(2, 10), Op::U8Xor(3, 11), Op::U8Xor(4, 12), Op::U8Xor(5, 13), Op::U8Xor(6, 14), Op::U8Xor(7, 15)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_153() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22])], ctrl: Ctrl::Return(1, vec![23]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(150, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(153, vec![11, 21], 1, false), Op::Store(vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(2, vec![32]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_154() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(151, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(154, vec![11, 21], 1, false), Op::Store(vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(2, vec![32]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_155() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(152, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(155, vec![11, 21], 1, false), Op::Store(vec![22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(2, vec![32]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_156() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4, 4, 4, 4]), Op::Store(vec![2, 3, 2, 2, 2, 2, 2, 2, 2, 5]), Op::Call(149, vec![6, 1], 1, false), Op::Call(140, vec![0, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_157() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4, 4, 4, 4]), Op::Store(vec![2, 3, 2, 2, 2, 2, 2, 2, 2, 5]), Op::Call(149, vec![6, 1], 1, false), Op::Call(146, vec![0, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_158() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(238)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(70)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 2, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 4, 15, 17, 18, 19, 20, 21, 22, 23, 2, 20, 24, 25])], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_159() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(66)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(166)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 4, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_160() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(50)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(111)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 0, 21, 22, 23, 24, 25, 26, 15, 27, 28, 6])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_161() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(10)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(47)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 2, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 6, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_162() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(247)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(204)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 18, 16, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_163() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(182)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(12)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1, 15, 20, 21, 10, 22, 23, 24, 25, 26, 27, 0])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_164() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(124)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(122)), Op::Store(vec![0, 1, 2, 3, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 17, 18, 19, 20, 21, 22, 23, 24, 25, 6, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_165() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(157)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(243)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_166() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(25)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(166)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 26, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_167() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(19)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(17)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 2, 16, 17, 18, 19, 6, 20, 21, 22, 23, 24, 25, 26, 27, 20, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_168() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(83)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(223)), Op::Store(vec![0, 1, 2, 3, 4, 5, 0, 6, 7, 8, 9, 10, 11, 12, 13, 2, 14, 15, 5, 16, 17, 18, 19, 20, 21, 8, 22, 23, 24, 25, 26, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_169() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(208)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(73)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_170() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(32)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(64)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 20, 28, 29, 5])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_171() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(70)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 23, 1, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_172() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(162)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(101)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_173() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(62)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(184)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_174() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(187)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_175() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(55)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(240)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 2, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_176() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(91)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(171)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 15, 21, 22, 23, 24, 25, 26, 27, 8, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_177() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(171)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(63)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_178() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(17)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(133)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 8, 11, 12, 5, 13, 14, 15, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_179() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(130)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(55)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 13, 5, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_180() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(222)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(52)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 12, 17, 18, 19, 20, 21, 22, 23, 0, 24, 25, 26, 17, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_181() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(147)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(225)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_182() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(119)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(93)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 18, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_183() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(205)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 12, 15, 16, 7, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 2, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_184() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(37)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(190)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 5, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_185() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(211)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(55)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 9, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_186() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(158)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(146)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 4, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_187() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(162)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(98)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 5, 23, 2, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_188() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(221)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(62)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_189() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(87)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(52)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(60)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_190() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(82)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(250)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 15, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_191() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(186)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(48)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 11, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 4, 25, 26, 15, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_192() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(182)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(149)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1, 18, 2, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_193() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(209)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(143)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_194() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(35)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(112)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 13, 21, 22, 9, 23, 24, 6, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_195() -> Function { + Function { body: Block { ops: vec![Op::Call(189, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(190, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(191, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(192, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(193, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![11]) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 16, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_196() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![0, 1, 0, 0, 0, 0, 0, 0, 0, 3]), Op::Const(G::from_u64(7)), Op::Store(vec![5, 0, 4, 0])], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_197() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), Op::Store(vec![0, 1, 0, 0, 0, 0, 0, 0, 0, 2]), Op::Const(G::from_u64(7)), Op::Store(vec![4, 0, 3, 0])], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_198() -> Function { + Function { body: Block { ops: vec![Op::Call(189, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(196, vec![], 1, false)], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(190, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(197, vec![], 1, false)], ctrl: Ctrl::Return(1, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(193, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(199, vec![1], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(191, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false), Op::Call(192, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false), Op::Add(10, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(3, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(14, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(4, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 17], 1, false), Op::Call(428, vec![18, 2], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(200, vec![19], 2, false)], ctrl: Ctrl::Return(5, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![19], 2, false)], ctrl: Ctrl::Return(6, vec![20, 21]) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 28, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_199() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(3)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(792, vec![0, 4], 1, false), Op::Call(125, vec![5], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(194, vec![], 1, false), Op::Call(2, vec![9, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(196, vec![], 1, false)], ctrl: Ctrl::Return(1, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(2, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(3, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 20, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_200() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Call(187, vec![], 1, false), Op::Call(2, vec![2, 5], 1, false), Op::Call(188, vec![], 1, false), Op::Call(2, vec![2, 7], 1, false), Op::Add(6, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(2, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_201() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(1, vec![5, 6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(2, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_202() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(250)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(43)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 2, 12, 13, 3, 14, 15, 16, 17, 18, 19, 20, 21, 22, 17, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_203() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(134)), Op::Store(vec![0, 1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 9, 20, 21, 22, 23, 24, 25, 26, 2, 16, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_204() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(144)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(233)), Op::Store(vec![0, 1, 2, 3, 4, 5, 2, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_205() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(47)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(13)), Op::Store(vec![0, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 2, 22, 23, 24, 25, 26, 3, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_206() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(17)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(40)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_207() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(5)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 13, 6, 20, 21, 22, 23, 24, 25, 26, 19, 27, 4])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_208() -> Function { + Function { body: Block { ops: vec![Op::Call(202, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(205, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(206, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_209() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(188, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Const(G::from_u64(0)), Op::Store(vec![1, 2, 4, 5])], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(187, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Const(G::from_u64(0)), Op::Store(vec![1, 2, 4, 5])], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_210() -> Function { + Function { body: Block { ops: vec![Op::Call(213, vec![1], 3, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![5, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Call(254, vec![4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8])], ctrl: Ctrl::Return(1, vec![7, 9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(254, vec![3], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(2, vec![9, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11]), Op::Store(vec![9, 10, 9, 9, 9, 9, 9, 9, 9, 12]), Op::Call(149, vec![13, 8], 1, false), Op::Call(147, vec![6, 14], 1, false), Op::Call(133, vec![15], 1, false)], ctrl: Ctrl::Return(3, vec![11, 16]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 13, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_211() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(3)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![0, 6], 1, false), Op::Const(G::from_u64(2)), Op::Call(792, vec![0, 8], 1, false), Op::Call(210, vec![5, 7], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13]) }), (G::from_u64(1), Block { ops: vec![Op::Call(210, vec![5, 9], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(2, vec![14, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(135, vec![13, 11], 1, false), Op::Sub(14, 15), Op::Call(209, vec![16], 1, false)], ctrl: Ctrl::Return(3, vec![14, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 18, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_212() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![0, 4], 1, false), Op::Call(125, vec![5], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(207, vec![], 1, false), Op::Call(2, vec![9, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(1, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![7], 1, false), Op::Const(G::from_u64(4)), Op::U32LessThan(14, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(2, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![7, 17], 1, false), Op::Call(125, vec![18], 2, false), Op::Load(4, 19)], ctrl: Ctrl::Match(21, [(G::from_u64(2), Block { ops: vec![Op::Call(204, vec![], 1, false), Op::Call(2, vec![22, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![27, 27, 27, 27])], ctrl: Ctrl::Return(3, vec![27, 28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![20], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(27, 28)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![30, 30, 30, 30])], ctrl: Ctrl::Return(4, vec![30, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![20, 30], 1, false), Op::Const(G::from_u64(2)), Op::Call(792, vec![7, 32], 1, false), Op::Const(G::from_u64(3)), Op::Call(792, vec![7, 34], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Store(vec![30, 35, 37]), Op::Store(vec![30, 33, 38]), Op::Store(vec![30, 31, 39]), Op::Call(211, vec![40], 2, false)], ctrl: Ctrl::Return(5, vec![41, 42]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![25, 25, 25, 25])], ctrl: Ctrl::Return(6, vec![25, 26]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(7, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 8, auxiliaries: 54, lookups: 40 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_213() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(203, vec![], 1, false), Op::Call(2, vec![4, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![2], 1, false), Op::Const(G::from_u64(2)), Op::Sub(9, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(792, vec![2, 13], 1, false), Op::Call(792, vec![2, 12], 1, false)], ctrl: Ctrl::Return(0, vec![12, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(2, vec![9, 10, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(3, vec![7, 8, 8]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 12, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_214() -> Function { + Function { body: Block { ops: vec![Op::Call(202, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(5, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Return(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(400, vec![1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Call(792, vec![8, 9], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![8, 11], 1, false), Op::Call(210, vec![10, 12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(1, vec![15, 16]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(256, vec![14], 1, false)], ctrl: Ctrl::Return(2, vec![15, 16]) })].into_iter().collect(), None) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(205, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(215, vec![1, 2], 1, false), Op::Call(211, vec![7], 2, false)], ctrl: Ctrl::Return(3, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(206, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(212, vec![1], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(5, vec![9, 10]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 17, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_215() -> Function { + Function { body: Block { ops: vec![Op::Call(398, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Call(216, vec![7, 1], 1, false), Op::Call(216, vec![10, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 13, 11]), Op::Store(vec![14, 12, 15]), Op::Store(vec![14, 4, 16])], ctrl: Ctrl::Return(3, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 16, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_216() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(398, vec![3, 1], 1, false), Op::Call(266, vec![2, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_217() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(76)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(192)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 19, 21, 22, 23, 24, 25, 26, 27, 28, 13, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_218() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(14)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(12)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 14, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_219() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(69)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(207)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(20)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_220() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(207)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(139)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(87)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 8, 22, 23, 24, 25, 9, 26, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_221() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(57)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(2)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 10, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_222() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(179)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(247)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_223() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(193)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(74)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 4, 17, 18, 19, 20, 21, 20, 5, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_224() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(97)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(147)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(58)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 3, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_225() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(47)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(212)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(194)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(115)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 11, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 10, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_226() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(222)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(181)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(151)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_227() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(77)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(104)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_228() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(218)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(249)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(17)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_229() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(34)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(126)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(191)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(210)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(45)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 12, 15, 16, 17, 17, 18, 16, 19, 6, 20, 21, 22, 23, 24, 3, 25, 26])], ctrl: Ctrl::Return(0, vec![27]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_230() -> Function { + Function { body: Block { ops: vec![Op::Call(217, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(219, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(224, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(225, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(226, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(228, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![15]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 8, auxiliaries: 22, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_231() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Call(219, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 6], 1, false), Op::Call(245, vec![7, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 10, 9, 12])], ctrl: Ctrl::Return(0, vec![10, 13]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(1, vec![10, 11]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(2, vec![6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(217, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 10], 1, false), Op::Load(4, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![14], 1, false), Op::Call(244, vec![16], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![19, 20, 17, 20])], ctrl: Ctrl::Return(4, vec![18, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(5, vec![16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(6, vec![16, 17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(224, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(232, vec![1], 2, false)], ctrl: Ctrl::Return(7, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(225, vec![], 1, false), Op::Call(2, vec![0, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(232, vec![1], 2, false)], ctrl: Ctrl::Return(8, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(226, vec![], 1, false), Op::Call(2, vec![0, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(233, vec![1], 2, false)], ctrl: Ctrl::Return(9, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(228, vec![], 1, false), Op::Call(2, vec![0, 14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(546, vec![0, 1, 2], 2, false)], ctrl: Ctrl::Return(10, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![], 1, false), Op::Call(2, vec![0, 16], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(11, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 20], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 22], 1, false), Op::Load(4, 21)], ctrl: Ctrl::Match(24, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 23)], ctrl: Ctrl::Match(28, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Call(789, vec![26, 30], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![34, 33, 32, 35])], ctrl: Ctrl::Return(12, vec![33, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![32, 32, 32, 32])], ctrl: Ctrl::Return(13, vec![32, 33]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![32, 32, 32, 32])], ctrl: Ctrl::Return(14, vec![32, 33]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![28, 28, 28, 28])], ctrl: Ctrl::Return(15, vec![28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![28, 28, 28, 28])], ctrl: Ctrl::Return(16, vec![28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(17, vec![18, 19]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 41, lookups: 28 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_232() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![0, 4], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(235, vec![8], 1, false), Op::Call(244, vec![10], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![12, 13, 11, 13]), Op::Const(G::from_u64(2)), Op::Call(220, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17]), Op::Store(vec![15, 16, 18, 13]), Op::Const(G::from_u64(3)), Op::Store(vec![20, 19, 14, 13])], ctrl: Ctrl::Return(1, vec![17, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(2, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 21, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_233() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![0, 4], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(227, vec![], 1, false), Op::Store(vec![13, 13, 13]), Op::Const(G::from_u64(0)), Op::Store(vec![14, 15, 16, 17])], ctrl: Ctrl::Return(1, vec![13, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(2, vec![13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(4, vec![10, 11]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 20, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_234() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(238, vec![2, 3], 2, false), Op::Call(234, vec![5], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_235() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(65)), Op::Call(236, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_236() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(238, vec![3, 4], 2, false), Op::Call(236, vec![6, 5], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_237() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(192)), Op::U8LessThan(0, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Sub(0, 5)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_238() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(194)), Op::U8LessThan(0, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(224)), Op::U8LessThan(0, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(192)), Op::Sub(0, 11), Op::Const(G::from_u64(64)), Op::Mul(12, 13), Op::Call(237, vec![9], 1, false), Op::Add(14, 15)], ctrl: Ctrl::Return(1, vec![16, 10]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(240)), Op::U8LessThan(0, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(224)), Op::Sub(0, 16), Op::Const(G::from_u64(4096)), Op::Mul(17, 18), Op::Call(237, vec![11], 1, false), Op::Const(G::from_u64(64)), Op::Mul(20, 21), Op::Call(237, vec![14], 1, false), Op::Add(22, 23), Op::Add(19, 24), Op::Const(G::from_u64(2048)), Op::U32LessThan(25, 26)], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![25, 15]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(240)), Op::Sub(0, 19), Op::Const(G::from_u64(262144)), Op::Mul(20, 21), Op::Call(237, vec![11], 1, false), Op::Const(G::from_u64(4096)), Op::Mul(23, 24), Op::Call(237, vec![14], 1, false), Op::Const(G::from_u64(64)), Op::Mul(26, 27), Op::Call(237, vec![17], 1, false), Op::Add(28, 29), Op::Add(25, 30), Op::Add(22, 31), Op::Const(G::from_u64(65536)), Op::U32LessThan(32, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![32, 18]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 26, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_239() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![1, 1, 1]), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Const(G::from_u64(2)), Op::Call(221, vec![], 1, false), Op::Store(vec![6, 7, 5, 1]), Op::Call(222, vec![], 1, false), Op::Store(vec![6, 9, 5, 1]), Op::Call(223, vec![], 1, false), Op::Store(vec![6, 11, 4, 1]), Op::Call(220, vec![], 1, false), Op::Store(vec![6, 13, 4, 1]), Op::Call(219, vec![], 1, false), Op::Store(vec![6, 15, 4, 1]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 8, 12, 1]), Op::Store(vec![17, 10, 12, 1]), Op::Call(240, vec![0, 18, 19, 14], 1, false), Op::Store(vec![17, 16, 20, 1])], ctrl: Ctrl::Return(0, vec![21]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 18 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_240() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(238, vec![5, 6], 2, false), Op::Call(244, vec![7], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 9, 11]), Op::Const(G::from_u64(3)), Op::Store(vec![13, 3, 12, 11]), Op::Store(vec![13, 2, 14, 11]), Op::Call(240, vec![8, 1, 2, 3], 1, false), Op::Store(vec![13, 15, 16, 11])], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_241() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![7], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23]), Op::Call(347, vec![14, 24], 1, false), Op::Load(4, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![28, 4, 30], 1, false), Op::Call(434, vec![31, 1], 1, false)], ctrl: Ctrl::Return(0, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![30, 25, 4, 31]), Op::Call(434, vec![32, 1], 1, false)], ctrl: Ctrl::Return(1, vec![33]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 31, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_242() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(239, vec![4], 1, false), Op::Call(241, vec![6, 1], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_243() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(137, vec![0, 1], 2, false), Op::Call(137, vec![3, 1], 2, false), Op::Call(137, vec![5, 1], 2, false), Op::Call(137, vec![7, 1], 2, false)], ctrl: Ctrl::Return(0, vec![2, 4, 6, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_244() -> Function { + Function { body: Block { ops: vec![Op::Call(243, vec![0], 4, true), Op::Const(G::from_u64(0)), Op::U8Xor(1, 5), Op::U8Xor(2, 5), Op::U8Xor(3, 5), Op::U8Xor(4, 5), Op::Const(G::from_u64(256)), Op::Mul(10, 7), Op::Const(G::from_u64(65536)), Op::Mul(12, 8), Op::Const(G::from_u64(16777216)), Op::Mul(14, 9), Op::Add(13, 15), Op::Add(11, 16), Op::Add(6, 17), Op::AssertEq(vec![0], vec![18], Some("u32 byte split does not recompose to the original value".into())), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19]), Op::Store(vec![5, 6, 7, 8, 9, 5, 5, 5, 5, 20]), Op::Call(133, vec![21], 1, false)], ctrl: Ctrl::Return(0, vec![22]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_245() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![0, 1], 1, false), Op::Call(125, vec![2], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(221, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![4], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(0, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(1, vec![12, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(222, vec![], 1, false), Op::Call(2, vec![6, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Return(2, vec![13, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![4], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(792, vec![4, 14], 1, false), Op::Call(246, vec![15, 1], 2, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19])], ctrl: Ctrl::Return(3, vec![18, 20]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(792, vec![4, 18], 1, false), Op::Call(245, vec![19, 1], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![22, 21]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(251, vec![17, 21], 1, false)], ctrl: Ctrl::Return(5, vec![22, 23]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(6, vec![14, 16]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(7, vec![9, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 8, auxiliaries: 22, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_246() -> Function { + Function { body: Block { ops: vec![Op::Call(247, vec![0], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![0, 1], 1, false), Op::Call(247, vec![4], 2, false)], ctrl: Ctrl::Return(1, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_247() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(220, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(11, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(248, vec![13], 2, false)], ctrl: Ctrl::Return(1, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![15, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![15, 15]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9, 9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![5, 5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_248() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Add(8, 9), Op::Add(7, 21), Op::Add(6, 22), Op::Add(5, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![26, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(3, 26), Op::Const(G::from_u64(65536)), Op::Mul(4, 28), Op::Add(27, 29), Op::Add(2, 30), Op::Const(G::from_u64(55296)), Op::U32LessThan(31, 32)], ctrl: Ctrl::Match(33, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![34, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(57343)), Op::U32LessThan(34, 31)], ctrl: Ctrl::Match(35, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![36, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1114112)), Op::U32LessThan(31, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![38, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![38, 38]) }))) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![21, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![11, 11]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 45, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_249() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::U32LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Sub(0, 4), Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(249, vec![5, 7], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_250() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(249, vec![0, 1], 2, false), Op::Call(249, vec![3, 1], 2, false), Op::Call(249, vec![5, 1], 2, false)], ctrl: Ctrl::Return(0, vec![2, 4, 6, 7]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_251() -> Function { + Function { body: Block { ops: vec![Op::Call(250, vec![0], 4, true), Op::Const(G::from_u64(0)), Op::U8Xor(2, 6), Op::U8Xor(3, 6), Op::U8Xor(4, 6), Op::U8Xor(5, 6), Op::Const(G::from_u64(64)), Op::U32LessThan(7, 11), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("utf8 group 0 is not a 6-bit value".into())), Op::U32LessThan(8, 11), Op::AssertEq(vec![14], vec![13], Some("utf8 group 1 is not a 6-bit value".into())), Op::U32LessThan(9, 11), Op::AssertEq(vec![15], vec![13], Some("utf8 group 2 is not a 6-bit value".into())), Op::U32LessThan(10, 11), Op::AssertEq(vec![16], vec![13], Some("utf8 group 3 is not a 6-bit value".into())), Op::Mul(8, 11), Op::Const(G::from_u64(4096)), Op::Mul(9, 18), Op::Const(G::from_u64(262144)), Op::Mul(10, 20), Op::Add(19, 21), Op::Add(17, 22), Op::Add(7, 23), Op::AssertEq(vec![0], vec![24], Some("utf8 groups do not recompose to the codepoint".into())), Op::Const(G::from_u64(128)), Op::U32LessThan(0, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![27, 0, 1])], ctrl: Ctrl::Return(0, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2048)), Op::U32LessThan(0, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Add(7, 29), Op::Const(G::from_u64(192)), Op::Add(8, 31), Op::Const(G::from_u64(0)), Op::Store(vec![33, 30, 1]), Op::Store(vec![33, 32, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(65536)), Op::U32LessThan(0, 29)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Add(7, 31), Op::Add(8, 31), Op::Const(G::from_u64(224)), Op::Add(9, 34), Op::Const(G::from_u64(0)), Op::Store(vec![36, 32, 1]), Op::Store(vec![36, 33, 37]), Op::Store(vec![36, 35, 38])], ctrl: Ctrl::Return(2, vec![39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(128)), Op::Add(7, 31), Op::Add(8, 31), Op::Add(9, 31), Op::Const(G::from_u64(240)), Op::Add(10, 35), Op::Const(G::from_u64(0)), Op::Store(vec![37, 32, 1]), Op::Store(vec![37, 33, 38]), Op::Store(vec![37, 34, 39]), Op::Store(vec![37, 36, 40])], ctrl: Ctrl::Return(3, vec![41]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 58, lookups: 51 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_252() -> Function { + Function { body: Block { ops: vec![Op::Call(159, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(160, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(174, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(185, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(186, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(181, vec![], 1, false), Op::Call(2, vec![0, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(182, vec![], 1, false), Op::Call(2, vec![0, 27], 1, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(183, vec![], 1, false), Op::Call(2, vec![0, 29], 1, false)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(184, vec![], 1, false), Op::Call(2, vec![0, 31], 1, false)], ctrl: Ctrl::Match(32, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![33]) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 17, auxiliaries: 49, lookups: 33 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_253() -> Function { + Function { body: Block { ops: vec![Op::Call(163, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false), Op::Call(164, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false), Op::Call(165, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false), Op::Call(166, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false), Op::Call(167, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false), Op::Call(168, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false), Op::Call(169, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false), Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false), Op::Call(171, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false), Op::Call(172, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(8, 25), Op::Add(6, 26), Op::Add(4, 27), Op::Add(2, 28)], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_254() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(1, vec![5, 7]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(158, vec![], 1, false), Op::Call(2, vec![2, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(2, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8])], ctrl: Ctrl::Return(3, vec![7, 9]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(255, vec![2, 3], 2, false)], ctrl: Ctrl::Return(4, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(5, vec![5, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_255() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(159, vec![], 1, false), Op::Call(2, vec![3, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(254, vec![1], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(126, vec![9], 1, false)], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(1, vec![10, 12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(2, vec![8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(3, vec![6, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_256() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![1, 2, 0, 2])], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_257() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(254, vec![3], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(161, vec![], 1, false), Op::Call(2, vec![6, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(133, vec![10], 1, false)], ctrl: Ctrl::Return(0, vec![13, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(162, vec![], 1, false), Op::Call(2, vec![6, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(126, vec![10], 1, false), Op::Call(133, vec![16], 1, false)], ctrl: Ctrl::Return(1, vec![15, 15, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16, 16, 16])], ctrl: Ctrl::Return(2, vec![15, 15, 17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(3, vec![11, 11, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(4, vec![9, 9, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(5, vec![5, 5, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_258() -> Function { + Function { body: Block { ops: vec![Op::Call(133, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Call(144, vec![2], 1, false), Op::Sub(3, 4), Op::Mul(0, 5)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Call(161, vec![], 1, false)], ctrl: Ctrl::Yield(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(162, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![7]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(136, vec![2], 1, false), Op::Call(133, vec![8], 1, false)], ctrl: Ctrl::Yield(3, vec![9]) })), 1, 3, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Const(G::from_u64(0)), Op::Store(vec![10, 7, 12, 13]), Op::Call(256, vec![8], 1, false), Op::Store(vec![9, 14, 15, 13])], ctrl: Ctrl::Return(4, vec![16]) })) })) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_259() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(128, vec![1, 3], 1, false), Op::Call(258, vec![0, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(135, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(134, vec![3, 1], 1, false), Op::Call(258, vec![2, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(134, vec![1, 3], 1, false), Op::Call(258, vec![0, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_260() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(258, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(147, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(144, vec![4], 1, false), Op::Sub(5, 6), Op::Mul(0, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(134, vec![2, 4], 1, false), Op::Call(258, vec![9, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(258, vec![9, 4], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_261() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6]), Op::Call(258, vec![5, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(146, vec![1, 3], 1, false), Op::Call(147, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(144, vec![6], 1, false), Op::Sub(7, 8), Op::Mul(0, 9)], ctrl: Ctrl::MatchContinue(10, [(G::from_u64(1), Block { ops: vec![Op::Call(126, vec![5], 1, false)], ctrl: Ctrl::Yield(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![5]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(0, 2), Op::Mul(12, 13), Op::Sub(2, 14), Op::Add(0, 15), Op::Const(G::from_u64(1)), Op::Call(144, vec![11], 1, false), Op::Sub(17, 18), Op::Mul(16, 19), Op::Call(258, vec![20, 11], 1, false)], ctrl: Ctrl::Return(3, vec![21]) })) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 13, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_262() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(258, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(147, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(144, vec![4], 1, false), Op::Sub(5, 6), Op::Mul(0, 7)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(1), Block { ops: vec![Op::Call(134, vec![2, 4], 1, false)], ctrl: Ctrl::Yield(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![4]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12]), Op::Store(vec![10, 11, 10, 10, 10, 10, 10, 10, 10, 13]), Op::Call(126, vec![2], 1, false), Op::Call(146, vec![15, 14], 1, false), Op::Call(135, vec![16, 9], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(134, vec![2, 9], 1, false), Op::Call(258, vec![18, 19], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(258, vec![18, 9], 1, false)], ctrl: Ctrl::Return(4, vec![19]) }))) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 15, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_263() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]), Op::Call(258, vec![4, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(147, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(144, vec![4], 1, false), Op::Sub(5, 6), Op::Mul(0, 7)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(1), Block { ops: vec![Op::Call(134, vec![2, 4], 1, false)], ctrl: Ctrl::Yield(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![4]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Call(146, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Call(144, vec![4], 1, false), Op::Sub(11, 12), Op::Mul(0, 13)], ctrl: Ctrl::MatchContinue(14, [(G::from_u64(1), Block { ops: vec![Op::Call(126, vec![10], 1, false)], ctrl: Ctrl::Yield(3, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(4, vec![10]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(144, vec![15], 1, false), Op::Sub(16, 17), Op::Mul(0, 18), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16, 16, 16]), Op::Store(vec![20, 21, 20, 20, 20, 20, 20, 20, 20, 22]), Op::Call(126, vec![2], 1, false), Op::Call(146, vec![24, 23], 1, false), Op::Call(135, vec![25, 9], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Call(258, vec![19, 15], 1, false)], ctrl: Ctrl::Return(5, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28]), Op::Store(vec![27, 28, 27, 27, 27, 27, 27, 27, 27, 29]), Op::Call(259, vec![19, 15, 27, 30], 1, false)], ctrl: Ctrl::Return(6, vec![31]) }))) })) })) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 24, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_264() -> Function { + Function { body: Block { ops: vec![Op::Call(398, vec![1, 2], 1, false), Op::Call(790, vec![3], 1, false), Op::Call(166, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false), Op::Call(171, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false), Op::Add(6, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(4, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(0, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![3, 12], 1, false), Op::Call(257, vec![13], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(171, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(1), Block { ops: vec![Op::Call(256, vec![16], 1, false)], ctrl: Ctrl::Yield(1, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(19, 15), Op::Call(144, vec![16], 1, false), Op::Sub(19, 21), Op::Mul(20, 22), Op::Call(258, vec![23, 16], 1, false)], ctrl: Ctrl::Yield(2, vec![24]) })), 1, 4, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(801, vec![3, 20], 1, false), Op::Call(266, vec![19, 21], 1, false)], ctrl: Ctrl::Return(3, vec![20, 22]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(4, vec![17, 18]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(4, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(5, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![3, 12], 1, false), Op::Call(257, vec![13], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(265, vec![0, 3, 15, 16], 2, false)], ctrl: Ctrl::Return(6, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(7, vec![17, 18]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 27, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_265() -> Function { + Function { body: Block { ops: vec![Op::Call(169, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false), Op::Call(172, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false), Op::Add(7, 9), Op::Add(5, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 12], 1, false), Op::Call(254, vec![13], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(169, vec![], 1, false), Op::Call(2, vec![0, 16], 1, false)], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(1), Block { ops: vec![Op::Call(262, vec![2, 3, 15], 1, false)], ctrl: Ctrl::Yield(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(170, vec![], 1, false), Op::Call(2, vec![0, 18], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Call(263, vec![2, 3, 15], 1, false)], ctrl: Ctrl::Yield(1, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22]), Op::Store(vec![20, 21, 20, 20, 20, 20, 20, 20, 20, 23]), Op::Call(147, vec![15, 24], 1, false), Op::Call(144, vec![25], 1, false), Op::Sub(22, 26), Op::Mul(2, 27), Op::Call(149, vec![3, 15], 1, false), Op::Call(258, vec![28, 29], 1, false)], ctrl: Ctrl::Yield(2, vec![30]) }))) })), 1, 11, 8, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(801, vec![1, 20], 1, false), Op::Call(266, vec![18, 21], 1, false)], ctrl: Ctrl::Return(3, vec![19, 22]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(4, vec![16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 12], 1, false), Op::Call(257, vec![13], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(163, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(1), Block { ops: vec![Op::Call(259, vec![2, 3, 15, 16], 1, false)], ctrl: Ctrl::Yield(5, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(164, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(21, 15), Op::Call(144, vec![16], 1, false), Op::Sub(21, 23), Op::Mul(22, 24), Op::Call(259, vec![2, 3, 25, 16], 1, false)], ctrl: Ctrl::Yield(6, vec![26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(165, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(2, 15), Op::Mul(23, 24), Op::Sub(15, 25), Op::Add(2, 26), Op::Const(G::from_u64(1)), Op::Call(144, vec![3], 1, false), Op::Sub(28, 29), Op::Call(144, vec![16], 1, false), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(27, 33), Op::Call(140, vec![3, 16], 1, false), Op::Call(258, vec![34, 35], 1, false)], ctrl: Ctrl::Yield(7, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(167, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Call(260, vec![2, 3, 16], 1, false)], ctrl: Ctrl::Yield(8, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(261, vec![2, 3, 15, 16], 1, false)], ctrl: Ctrl::Yield(9, vec![25]) }))) }))) }))) })), 1, 13, 8, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(801, vec![1, 21], 1, false), Op::Call(266, vec![19, 22], 1, false)], ctrl: Ctrl::Return(10, vec![20, 23]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(11, vec![17, 18]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 12, auxiliaries: 30, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_266() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 0, 3, 6]), Op::Call(266, vec![7, 4], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_267() -> Function { + Function { body: Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(128, vec![1, 2], 1, false), Op::Call(133, vec![6], 1, false), Op::Call(256, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![5, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(174, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(134, vec![1, 2], 1, false), Op::Call(133, vec![8], 1, false), Op::Call(256, vec![9], 1, false)], ctrl: Ctrl::Return(1, vec![7, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(140, vec![1, 2], 1, false), Op::Call(133, vec![10], 1, false), Op::Call(256, vec![11], 1, false)], ctrl: Ctrl::Return(2, vec![9, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(146, vec![1, 2], 1, false), Op::Call(133, vec![12], 1, false), Op::Call(256, vec![13], 1, false)], ctrl: Ctrl::Return(3, vec![11, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(147, vec![1, 2], 1, false), Op::Call(133, vec![14], 1, false), Op::Call(256, vec![15], 1, false)], ctrl: Ctrl::Return(4, vec![13, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(148, vec![1, 2], 1, false), Op::Call(133, vec![16], 1, false), Op::Call(256, vec![17], 1, false)], ctrl: Ctrl::Return(5, vec![15, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(149, vec![1, 2], 1, false), Op::Call(133, vec![18], 1, false), Op::Call(256, vec![19], 1, false)], ctrl: Ctrl::Return(6, vec![17, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(153, vec![1, 2], 1, false), Op::Call(133, vec![20], 1, false), Op::Call(256, vec![21], 1, false)], ctrl: Ctrl::Return(7, vec![19, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(181, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(154, vec![1, 2], 1, false), Op::Call(133, vec![22], 1, false), Op::Call(256, vec![23], 1, false)], ctrl: Ctrl::Return(8, vec![21, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(182, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(155, vec![1, 2], 1, false), Op::Call(133, vec![24], 1, false), Op::Call(256, vec![25], 1, false)], ctrl: Ctrl::Return(9, vec![23, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(183, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(156, vec![1, 2], 1, false), Op::Call(133, vec![26], 1, false), Op::Call(256, vec![27], 1, false)], ctrl: Ctrl::Return(10, vec![25, 28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(184, vec![], 1, false), Op::Call(2, vec![0, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(157, vec![1, 2], 1, false), Op::Call(133, vec![28], 1, false), Op::Call(256, vec![29], 1, false)], ctrl: Ctrl::Return(11, vec![27, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(185, vec![], 1, false), Op::Call(2, vec![0, 27], 1, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(349, vec![1, 2], 1, false), Op::Call(209, vec![30], 1, false)], ctrl: Ctrl::Return(12, vec![29, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(186, vec![], 1, false), Op::Call(2, vec![0, 29], 1, false)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(135, vec![1, 2], 1, false), Op::Call(209, vec![32], 1, false)], ctrl: Ctrl::Return(13, vec![31, 33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![31, 31, 31, 31])], ctrl: Ctrl::Return(14, vec![31, 32]) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 15, auxiliaries: 44, lookups: 31 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_268() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![3, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![8, 0, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Const(G::from_u64(2)), Op::Sub(8, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 13], 1, false), Op::Load(4, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![19, 12, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(2, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(3, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(4, vec![11, 0, 13]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(5, vec![6, 0, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_269() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3, 3, 3, 3, 3, 3, 3, 3]), Op::Store(vec![2, 3, 2, 2, 2, 2, 2, 2, 2, 4]), Op::Call(134, vec![1, 5], 1, false), Op::Call(133, vec![6], 1, false), Op::Const(G::from_u64(2)), Op::Call(159, vec![], 1, false), Op::Store(vec![3, 3, 3]), Op::Store(vec![8, 9, 10, 2]), Op::Call(144, vec![7], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 11, 0, 14])], ctrl: Ctrl::Return(0, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(173, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Const(G::from_u64(0)), Op::Store(vec![13, 14, 16, 17]), Op::Const(G::from_u64(7)), Op::Store(vec![19, 17, 7, 17]), Op::Const(G::from_u64(3)), Op::Store(vec![21, 18, 0, 17]), Op::Store(vec![21, 22, 20, 17]), Op::Store(vec![21, 11, 23, 17])], ctrl: Ctrl::Return(1, vec![24]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_270() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 5)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(268, vec![5, 6], 3, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(133, vec![13], 1, false), Op::Call(144, vec![14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(269, vec![12, 14], 1, false)], ctrl: Ctrl::Return(2, vec![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 19, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_271() -> Function { + Function { body: Block { ops: vec![Op::Call(144, vec![1], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(266, vec![0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(173, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 7, 8]), Op::Const(G::from_u64(3)), Op::Store(vec![10, 9, 0, 8]), Op::Call(256, vec![1], 1, false), Op::Store(vec![10, 11, 12, 8]), Op::Call(266, vec![13, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6, 14]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_272() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(4), Block { ops: vec![Op::Call(125, vec![7], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(159, vec![], 1, false), Op::Call(2, vec![12, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Sub(17, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![10, 20], 1, false), Op::Load(4, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::EqZero(23)], ctrl: Ctrl::Return(1, vec![26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![20]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_273() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(792, vec![0, 4], 1, false), Op::Call(254, vec![7], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(1, vec![10, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Add(1, 2), Op::Const(G::from_u64(1)), Op::Add(10, 11), Op::Call(792, vec![0, 12], 1, false), Op::Call(272, vec![13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(792, vec![0, 10], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 16), Op::Call(801, vec![0, 17], 1, false), Op::Call(254, vec![15], 2, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(128, vec![20, 9], 1, false), Op::Call(256, vec![22], 1, false), Op::Call(266, vec![23, 18], 1, false)], ctrl: Ctrl::Return(3, vec![21, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(271, vec![15, 9, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }))) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 21, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_274() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Call(160, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Call(159, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 10], 1, false), Op::Call(254, vec![11], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(801, vec![1, 14], 1, false), Op::Call(126, vec![13], 1, false), Op::Call(256, vec![16], 1, false), Op::Call(266, vec![17, 15], 1, false)], ctrl: Ctrl::Return(1, vec![14, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(2, vec![14, 15]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(3, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 10], 1, false), Op::Call(254, vec![11], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(801, vec![1, 14], 1, false), Op::Call(136, vec![13], 1, false), Op::Call(133, vec![16], 1, false), Op::Call(256, vec![17], 1, false), Op::Call(266, vec![18, 15], 1, false)], ctrl: Ctrl::Return(4, vec![14, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(5, vec![14, 15]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(275, vec![0, 1, 3], 2, false)], ctrl: Ctrl::Return(6, vec![8, 9]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 22, lookups: 19 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_275() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 7], 1, false), Op::Call(254, vec![6], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(254, vec![8], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(267, vec![0, 10, 12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(801, vec![1, 15], 1, false), Op::Const(G::from_u64(1)), Op::Call(266, vec![14, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(3, vec![13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(254, vec![8], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(276, vec![0, 6, 12, 1], 2, false)], ctrl: Ctrl::Return(4, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(5, vec![13, 14]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_276() -> Function { + Function { body: Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 6], 1, false), Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false), Op::Add(7, 9), Op::Const(G::from_u64(1)), Op::Call(144, vec![2], 1, false), Op::Sub(11, 12), Op::Call(136, vec![2], 1, false), Op::Call(133, vec![14], 1, false), Op::Call(144, vec![15], 1, false), Op::Sub(11, 16), Op::Mul(13, 17), Op::Mul(10, 18), Op::Add(5, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![21, 21, 21, 21])], ctrl: Ctrl::Return(0, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(801, vec![3, 21], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(271, vec![1, 2, 22], 2, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(1, vec![25, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![25, 25, 25, 25])], ctrl: Ctrl::Return(2, vec![25, 26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(277, vec![0, 1, 2, 22], 1, false)], ctrl: Ctrl::Return(3, vec![23, 24]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 19, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_277() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![4, 0, 6, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 8, 1, 7]), Op::Call(256, vec![2], 1, false), Op::Store(vec![9, 10, 11, 7]), Op::Call(266, vec![12, 3], 1, false)], ctrl: Ctrl::Return(0, vec![13]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_278() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1, 2, 3, 4, 5, 6, 7, 8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(278, vec![12, 11, 2, 3, 4, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(2, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(278, vec![12, 1, 11, 3, 4, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(3, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(278, vec![12, 1, 2, 11, 4, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(4, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(278, vec![12, 1, 2, 3, 11, 5, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(5, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(278, vec![12, 1, 2, 3, 4, 11, 6, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(6, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(278, vec![12, 1, 2, 3, 4, 5, 11, 7, 8, 13], 8, false)], ctrl: Ctrl::Return(7, vec![14, 15, 16, 17, 18, 19, 20, 21]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(278, vec![12, 1, 2, 3, 4, 5, 6, 11, 8, 13], 8, false)], ctrl: Ctrl::Return(8, vec![14, 15, 16, 17, 18, 19, 20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(278, vec![12, 1, 2, 3, 4, 5, 6, 7, 11, 13], 8, false)], ctrl: Ctrl::Return(9, vec![14, 15, 16, 17, 18, 19, 20, 21]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 10, selectors: 10, auxiliaries: 20, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_279() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Call(279, vec![4, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_280() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(278, vec![0, 1, 1, 1, 1, 1, 1, 1, 1, 1], 8, false), Op::Const(G::from_u64(8)), Op::Call(279, vec![0, 10], 1, false), Op::Load(3, 11)], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Yield(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(280, vec![11], 1, false)], ctrl: Ctrl::Yield(1, vec![15]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Load(10, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Call(6, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![27, 27, 27, 27, 27, 27, 27, 27, 27, 27])], ctrl: Ctrl::Return(2, vec![28]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28]), Op::Store(vec![27, 2, 3, 4, 5, 6, 7, 8, 9, 29])], ctrl: Ctrl::Return(3, vec![30]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 2, 3, 4, 5, 6, 7, 8, 9, 15])], ctrl: Ctrl::Return(4, vec![27]) }))) })) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 29, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_281() -> Function { + Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(281, vec![2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(281, vec![2], 1, false), Op::Call(281, vec![3], 1, false), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(2, vec![13]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(281, vec![2], 1, false), Op::Call(281, vec![3], 1, false), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(3, vec![13]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 13, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_282() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Call(18, vec![3, 4, 5, 6, 7, 8, 9, 10], 1, false), Op::Call(792, vec![1, 12], 1, false), Op::Const(G::from_u64(0)), Op::Call(281, vec![13], 1, false), Op::Call(282, vec![11, 1], 1, false), Op::Store(vec![14, 15, 16])], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_283() -> Function { + Function { body: Block { ops: vec![Op::Load(18, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(792, vec![4, 23], 1, false), Op::Const(G::from_u64(1)), Op::Call(281, vec![24], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![25, 26, 27, 27])], ctrl: Ctrl::Return(0, vec![28]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Store(vec![23, 24, 23, 23])], ctrl: Ctrl::Return(1, vec![25]) }), (G::from_u64(2), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(792, vec![2, 23], 1, false), Op::Call(282, vec![14, 4], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 25, 27])], ctrl: Ctrl::Return(2, vec![28]) }), (G::from_u64(3), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(792, vec![3, 23], 1, false), Op::Call(282, vec![14, 4], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 25, 27])], ctrl: Ctrl::Return(3, vec![28]) }), (G::from_u64(4), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(792, vec![2, 23], 1, false), Op::Const(G::from_u64(8)), Op::Call(18, vec![14, 15, 16, 17, 18, 19, 20, 21], 1, false), Op::Call(283, vec![22, 1, 2, 3, 4], 1, false), Op::Store(vec![25, 24, 26, 27])], ctrl: Ctrl::Return(4, vec![28]) }), (G::from_u64(5), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(792, vec![2, 23], 1, false), Op::Call(295, vec![24], 1, false), Op::Call(234, vec![25], 0, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![26, 27, 25, 28])], ctrl: Ctrl::Return(5, vec![29]) }), (G::from_u64(6), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(792, vec![2, 23], 1, false), Op::Call(295, vec![24], 1, false), Op::Call(280, vec![25], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![27, 28, 26, 28])], ctrl: Ctrl::Return(6, vec![29]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(283, vec![6, 1, 2, 3, 4], 1, false), Op::Call(283, vec![7, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(7, vec![27]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(283, vec![9, 1, 2, 3, 4], 1, false), Op::Call(283, vec![10, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(8, vec![27]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(283, vec![11, 1, 2, 3, 4], 1, false), Op::Call(283, vec![12, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(9, vec![27]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(283, vec![11, 1, 2, 3, 4], 1, false), Op::Call(283, vec![12, 1, 2, 3, 4], 1, false), Op::Call(283, vec![13, 1, 2, 3, 4], 1, false), Op::Store(vec![23, 24, 25, 26])], ctrl: Ctrl::Return(10, vec![27]) }), (G::from_u64(11), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(801, vec![1, 23], 1, false), Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Call(283, vec![26, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(11, vec![28]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 12, auxiliaries: 25, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_284() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![10, 12, 13, 14, 15], 1, false), Op::Call(283, vec![11, 12, 13, 14, 15], 1, false), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![20, 19, 17, 18, 1, 16, 21, 21, 21, 21, 21, 21]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![20]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![21, 19, 17, 18, 20, 22, 22, 22, 22, 22, 22, 22]) })) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20, 19, 17, 18, 21, 21, 21, 21, 21, 21, 21, 21]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 17, selectors: 5, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_285() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![15, 16, 14, 0, 15, 15, 15, 15, 15, 15, 15, 15]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_286() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(4)), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![15, 16, 14, 0, 17, 17, 17, 17, 17, 17, 17, 17]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_287() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![37]) }), (G::from_u64(0), Block { ops: vec![Op::Call(287, vec![36], 1, false), Op::Const(G::from_u64(1)), Op::Add(37, 38)], ctrl: Ctrl::Return(1, vec![39]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 38, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_288() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(288, vec![37, 39], 34, false)], ctrl: Ctrl::Return(1, vec![40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 72, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_289() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![25, 29, 30, 31, 32], 1, false), Op::Const(G::from_u64(5)), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(18, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(18, vec![17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Call(287, vec![26], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![34, 35, 33, 36, 37, 38, 0, 27, 28, 39, 39, 39]) }))) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_290() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![33, 36, 37, 38, 39], 1, false), Op::Const(G::from_u64(6)), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(18, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(18, vec![17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Call(18, vec![25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![41, 42, 40, 34, 35, 43, 44, 45, 0, 46, 46, 46]) }))) }, layout: FunctionLayout { input_size: 40, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_291() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17, 17, 17])], ctrl: Ctrl::Return(0, vec![18]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![15, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(18, vec![7, 8, 9, 10, 11, 12, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 20), Op::Call(291, vec![16, 1, 2, 3, 4, 21], 1, false), Op::Store(vec![18, 5, 19, 17, 22])], ctrl: Ctrl::Return(1, vec![23]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 16, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_292() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![42, 46, 47, 48, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(291, vec![43, 46, 47, 48, 49, 51], 1, false), Op::Const(G::from_u64(7)), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(18, vec![10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Call(18, vec![18, 19, 20, 21, 22, 23, 24, 25], 1, false), Op::Call(18, vec![26, 27, 28, 29, 30, 31, 32, 33], 1, false), Op::Call(18, vec![34, 35, 36, 37, 38, 39, 40, 41], 1, false)], ctrl: Ctrl::Return(0, vec![53, 54, 50, 55, 56, 57, 58, 52, 0, 1, 44, 45]) }))) }, layout: FunctionLayout { input_size: 50, selectors: 1, auxiliaries: 8, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_293() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(2)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(5, vec![33, 34, 35], 1, false), Op::Call(22, vec![36, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false), Op::Call(124, vec![36], 49, false), Op::Load(3, 85), Op::Const(G::from_u64(1)), Op::AssertEq(vec![86, 87, 88], vec![89, 89, 89], Some("trailing bytes after constant on ch 2".into()))], ctrl: Ctrl::Return(0, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 88, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_294() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(3)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(4, vec![33, 34, 35], 1, true), Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![38]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 39, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_295() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(4)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(5, vec![33, 34, 35], 1, false), Op::Call(22, vec![36, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false)], ctrl: Ctrl::Return(0, vec![36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 36, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_296() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![2]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![2]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_297() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![0, 1], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(306, vec![12, 13], 1, false)], ctrl: Ctrl::Return(1, vec![15]) }))) }))) }, layout: FunctionLayout { input_size: 14, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_298() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(294, vec![0], 1, true)], ctrl: Ctrl::MatchContinue(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(296, vec![2, 3], 1, false)], ctrl: Ctrl::Match(50, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51])], ctrl: Ctrl::Yield(0, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![52, 52, 52]), Op::Store(vec![51, 0, 53])], ctrl: Ctrl::Yield(1, vec![54]) }))) })), 1, 4, 3, Box::new(Block { ops: vec![Op::Call(284, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 46, 47, 50, 48, 49], 12, false), Op::Store(vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62])], ctrl: Ctrl::Return(2, vec![63]) })) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49]), Op::Call(285, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 46, 47, 50, 48], 12, false), Op::Store(vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62])], ctrl: Ctrl::Return(3, vec![63]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49]), Op::Call(286, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 46, 47, 50, 48], 12, false), Op::Store(vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62])], ctrl: Ctrl::Return(4, vec![63]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(299, vec![0, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1, false)], ctrl: Ctrl::Return(5, vec![49]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(300, vec![10, 49], 1, false)], ctrl: Ctrl::Return(6, vec![50]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(18, vec![10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Call(301, vec![18, 49, 50], 1, false)], ctrl: Ctrl::Return(7, vec![51]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(302, vec![10, 49], 1, false)], ctrl: Ctrl::Return(8, vec![50]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![50, 50, 50]), Op::Store(vec![49, 0, 51]), Op::Call(292, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 0, 49, 46, 47, 52, 48], 12, false), Op::Store(vec![53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64])], ctrl: Ctrl::Return(9, vec![65]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 1, selectors: 10, auxiliaries: 68, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_299() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![9], 48, false)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(8), Block { ops: vec![Op::Call(794, vec![11, 1, 2, 3, 4, 5, 6, 7, 8], 45, false)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Call(294, vec![0], 1, true), Op::Call(297, vec![59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 11, 9], 1, false), Op::Call(284, vec![59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 55, 56, 104, 57, 103], 12, false), Op::Store(vec![105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116])], ctrl: Ctrl::Return(0, vec![117]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 109, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_300() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Call(303, vec![3, 1], 45, false)], ctrl: Ctrl::Match(50, [(G::from_u64(1), Block { ops: vec![Op::Call(306, vec![3, 0], 1, false), Op::Call(289, vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 0, 1, 47, 48, 95, 49], 12, false), Op::Store(vec![96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107])], ctrl: Ctrl::Return(0, vec![108]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 108, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_301() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(8), Block { ops: vec![Op::Call(303, vec![4, 1], 45, false)], ctrl: Ctrl::Match(51, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(52, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(288, vec![78, 2], 34, false), Op::Call(306, vec![4, 0], 1, false), Op::Call(290, vec![96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 0, 1, 48, 49, 130, 50], 12, false), Op::Store(vec![131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142])], ctrl: Ctrl::Return(0, vec![143]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 142, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_302() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Call(303, vec![3, 1], 45, false)], ctrl: Ctrl::Match(50, [(G::from_u64(2), Block { ops: vec![Op::Call(306, vec![3, 0], 1, false), Op::Call(292, vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 0, 1, 47, 48, 95, 49], 12, false), Op::Store(vec![96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107])], ctrl: Ctrl::Return(0, vec![108]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 108, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_303() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 49), Op::Call(303, vec![48, 50], 45, false)], ctrl: Ctrl::Return(1, vec![51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 94, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_304() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::AssertEq(vec![9], vec![0], Some("projection index bytes do not recompose to the index".into()))], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_305() -> Function { + Function { body: Block { ops: vec![Op::Call(303, vec![0, 2], 45, false), Op::Call(304, vec![2], 8, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![56, 48, 49, 50, 51, 52, 53, 54, 55, 1, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(1, vec![56, 48, 49, 50, 51, 52, 53, 54, 55, 1, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![56, 48, 49, 50, 51, 52, 53, 54, 55, 1, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57]) })].into_iter().collect(), None, 45, 0, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![101, 101, 101]), Op::Call(79, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 102, 102, 102, 102], 1, false), Op::Call(23, vec![103], 1, false)], ctrl: Ctrl::Return(3, vec![104]) })) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 102, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_306() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(307, vec![0, 1, 0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_307() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51])], ctrl: Ctrl::Return(0, vec![52]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(305, vec![0, 1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 53), Op::Call(307, vec![0, 1, 50, 54], 1, false), Op::Store(vec![51, 52, 55])], ctrl: Ctrl::Return(1, vec![56]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 51, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_308() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(2), Block { ops: vec![Op::Call(308, vec![2], 1, false), Op::Call(308, vec![3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![6]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(308, vec![3], 1, false)], ctrl: Ctrl::Return(6, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_309() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(309, vec![3, 6], 1, false)], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(309, vec![3, 6], 1, false), Op::Call(309, vec![4, 7], 1, false), Op::Mul(8, 9)], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(3), Block { ops: vec![Op::Call(309, vec![3, 6], 1, false), Op::Call(309, vec![4, 7], 1, false), Op::Mul(8, 9)], ctrl: Ctrl::Return(6, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(4), Block { ops: vec![Op::Sub(3, 6), Op::EqZero(8)], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(9, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 10, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_310() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(6, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(310, vec![4, 7], 1, false)], ctrl: Ctrl::Return(5, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_311() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(6, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(311, vec![0, 7], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(311, vec![4, 7], 1, false)], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_312() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(312, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_313() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Store(vec![6, 0, 7])], ctrl: Ctrl::Return(0, vec![5, 8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(0, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 0, 1])], ctrl: Ctrl::Return(1, vec![6, 8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(3, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Call(313, vec![0, 4], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 3, 8])], ctrl: Ctrl::Return(3, vec![7, 10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 19, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_314() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![1, 2]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 7, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(1, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![1, 2]), Op::Store(vec![9, 10, 0])], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(6, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(314, vec![5, 1, 2], 1, false), Op::Store(vec![10, 4, 11])], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 2]), Op::Store(vec![11, 12, 5])], ctrl: Ctrl::Return(3, vec![13]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 26, lookups: 23 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_315() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 3)], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(2, 6)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(8, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Sub(9, 11)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Call(315, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![13]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_316() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 2)], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(316, vec![3], 1, false), Op::U32LessThan(6, 5)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![6]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_317() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 3)], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(2, 6)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(8, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(317, vec![4, 1], 1, false), Op::Store(vec![13, 3, 14])], ctrl: Ctrl::Return(2, vec![15]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(10, 8)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(317, vec![0, 7], 1, false)], ctrl: Ctrl::Return(3, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(11, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(317, vec![4, 7], 1, false), Op::Store(vec![15, 3, 16])], ctrl: Ctrl::Return(4, vec![17]) }), (G::from_u64(0), Block { ops: vec![Op::Call(317, vec![4, 7], 1, false)], ctrl: Ctrl::Return(5, vec![15]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 31, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_318() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(319, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(319, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_319() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 2, 8]), Op::Store(vec![6, 9, 8])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(310, vec![1, 6], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 8]), Op::Store(vec![11, 12, 5])], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![10, 13, 0])], ctrl: Ctrl::Return(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(319, vec![5, 1, 2], 1, false), Op::Store(vec![10, 4, 11])], ctrl: Ctrl::Return(4, vec![12]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 16, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_320() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![7, 12, 10])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(310, vec![1, 7], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(314, vec![9, 2, 3], 1, false), Op::Store(vec![7, 8, 12]), Op::Store(vec![11, 13, 6])], ctrl: Ctrl::Return(1, vec![14]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13]), Op::Store(vec![11, 12, 14]), Op::Store(vec![1, 11, 15]), Op::Store(vec![11, 16, 0])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![6, 1, 2, 3], 1, false), Op::Store(vec![11, 5, 12])], ctrl: Ctrl::Return(3, vec![13]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 13, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_321() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(318, vec![3, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Call(321, vec![5, 1, 8, 3], 1, false)], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Call(321, vec![5, 1, 2, 3], 1, false), Op::Call(321, vec![6, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(322, vec![5, 6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(313, vec![5, 1], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(318, vec![3, 1, 2], 1, false), Op::Call(320, vec![9, 8, 5, 2], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(320, vec![3, 1, 5, 2], 1, false)], ctrl: Ctrl::Return(6, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_322() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(318, vec![4, 2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 8), Op::Call(321, vec![0, 2, 3, 4], 1, false), Op::Call(321, vec![6, 2, 9, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(322, vec![0, 6, 2, 3, 4], 1, false), Op::Call(322, vec![0, 7, 2, 3, 8], 1, false)], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Call(322, vec![0, 7, 2, 3, 4], 1, false), Op::Call(322, vec![6, 7, 2, 3, 8], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(4), Block { ops: vec![Op::Call(313, vec![6, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(318, vec![4, 2, 3], 1, false), Op::Call(320, vec![10, 9, 6, 3], 1, false), Op::Call(321, vec![0, 9, 3, 11], 1, false)], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(5, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(320, vec![4, 2, 6, 3], 1, false)], ctrl: Ctrl::Yield(6, vec![10]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(321, vec![0, 2, 3, 10], 1, false)], ctrl: Ctrl::Return(7, vec![11]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_323() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(324, vec![3, 1], 1, false), Op::Call(323, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_324() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(311, vec![8, 5], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(324, vec![0, 4], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(312, vec![5, 8], 1, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(9, 6)], ctrl: Ctrl::Yield(4, vec![13]) })].into_iter().collect(), None, 1, 6, 6, Box::new(Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::MatchContinue(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(5, vec![17]) }), (G::from_u64(0), Block { ops: vec![Op::Call(316, vec![7], 1, false), Op::Const(G::from_u64(1)), Op::Add(17, 18), Op::U32LessThan(19, 6)], ctrl: Ctrl::Yield(6, vec![20]) })].into_iter().collect(), None, 1, 7, 7, Box::new(Block { ops: vec![Op::Mul(13, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(7, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(8, vec![6]) }))) })) })) })), 1, 21, 14, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(9, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(10, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(317, vec![7, 10], 1, false)], ctrl: Ctrl::Yield(11, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None, 1, 4, 2, Box::new(Block { ops: vec![Op::Store(vec![5, 13, 14]), Op::Call(324, vec![15, 4], 1, false)], ctrl: Ctrl::Return(12, vec![16]) })) })) }))) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 13, auxiliaries: 42, lookups: 24 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_325() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(325, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_326() -> Function { + Function { body: Block { ops: vec![Op::Call(325, vec![0], 1, false), Op::Call(325, vec![1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 8)], ctrl: Ctrl::Match(13, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(310, vec![10, 13], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Sub(11, 14)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(315, vec![12, 15], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Call(326, vec![6, 9], 1, false)], ctrl: Ctrl::Return(3, vec![19]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![19]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![17]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_327() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(311, vec![6, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(327, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::MatchContinue(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(2, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(328, vec![8, 2], 1, false)], ctrl: Ctrl::Yield(3, vec![11]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(327, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(5, vec![12]) })].into_iter().collect(), None) })) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_328() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 3)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 7), Op::U32LessThan(8, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(328, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_329() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(311, vec![7, 1], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(329, vec![6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(330, vec![9, 2, 3], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(329, vec![6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![12]) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_330() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(6, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(330, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(330, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_331() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(327, vec![1, 5, 6], 1, false)], ctrl: Ctrl::Yield(2, vec![8]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(332, vec![7, 1, 5], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(331, vec![4, 1], 1, false)], ctrl: Ctrl::Return(5, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_332() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(2, 4)], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(329, vec![1, 2, 6, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(332, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_333() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![3, 1, 3]), Op::Store(vec![1, 4, 3]), Op::Call(321, vec![0, 3, 1, 5], 1, false), Op::Call(323, vec![6, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_334() -> Function { + Function { body: Block { ops: vec![Op::Call(309, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(333, vec![0], 1, false), Op::Call(333, vec![1], 1, false), Op::Call(331, vec![6, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_335() -> Function { + Function { body: Block { ops: vec![Op::Call(309, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Call(333, vec![0], 1, false), Op::Call(333, vec![1], 1, false), Op::Call(326, vec![3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_336() -> Function { + Function { body: Block { ops: vec![Op::Call(341, vec![0], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(341, vec![1], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::U32LessThan(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(337, vec![0, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(337, vec![0, 1], 1, false)], ctrl: Ctrl::Return(3, vec![4]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 11, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_337() -> Function { + Function { body: Block { ops: vec![Op::Call(338, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(339, vec![1, 0], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(339, vec![0, 1], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(340, vec![0, 1], 1, false)], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 13, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_338() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(338, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(338, vec![4, 7], 1, false), Op::Call(338, vec![5, 8], 1, false), Op::Mul(9, 10)], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![9]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(3), Block { ops: vec![Op::Call(338, vec![4, 7], 1, false), Op::Call(338, vec![5, 8], 1, false), Op::Mul(9, 10)], ctrl: Ctrl::Return(7, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![9]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(4), Block { ops: vec![Op::Sub(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![9]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 12, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_339() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(338, vec![3, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(338, vec![4, 1], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_340() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(342, vec![0, 2], 2, false), Op::Call(342, vec![1, 2], 2, false), Op::Call(338, vec![3, 5], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::U32LessThan(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Store(vec![8, 0, 1])], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 12, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_341() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 5]) }), (G::from_u64(1), Block { ops: vec![Op::Call(341, vec![2], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 6)], ctrl: Ctrl::Return(1, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![6, 6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![4, 4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_342() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 5), Op::Call(342, vec![3, 6], 2, false)], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 1]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_343() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Call(336, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(308, vec![1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(336, vec![0, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(309, vec![0, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Store(vec![10, 0, 1])], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_344() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 2, 5])], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(344, vec![2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 6])], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(344, vec![2], 1, false), Op::Call(344, vec![3], 1, false), Op::Call(336, vec![4, 5], 1, false)], ctrl: Ctrl::Return(3, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(344, vec![2], 1, false), Op::Call(344, vec![3], 1, false), Op::Call(343, vec![4, 5], 1, false)], ctrl: Ctrl::Return(4, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 5, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_345() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(345, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(345, vec![3, 1], 1, false), Op::Call(345, vec![4, 1], 1, false), Op::Call(336, vec![5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(345, vec![3, 1], 1, false), Op::Call(345, vec![4, 1], 1, false), Op::Call(343, vec![5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(792, vec![1, 3], 1, false)], ctrl: Ctrl::Return(4, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_346() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(345, vec![3, 1], 1, false), Op::Call(346, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_347() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(348, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_348() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(345, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(346, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 7, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(347, vec![3, 1], 1, false), Op::Call(347, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(347, vec![3, 1], 1, false), Op::Call(347, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(347, vec![3, 1], 1, false), Op::Call(347, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(5, vec![10]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(347, vec![3, 1], 1, false), Op::Call(347, vec![4, 1], 1, false), Op::Call(347, vec![5, 1], 1, false), Op::Store(vec![6, 7, 8, 9])], ctrl: Ctrl::Return(6, vec![10]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 4, 7])], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(347, vec![5, 1], 1, false), Op::Store(vec![6, 3, 4, 7])], ctrl: Ctrl::Return(8, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_349() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![22]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Call(14, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Call(349, vec![11, 21], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![23]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_350() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(350, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_351() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(349, vec![1, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(350, vec![1, 3], 1, false)], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![4]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_352() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 5)], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![5]) }), (G::from_u64(3), Block { ops: vec![Op::Call(352, vec![2], 1, false), Op::Call(352, vec![3], 1, false), Op::Call(354, vec![5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(352, vec![2], 1, false), Op::Call(352, vec![3], 1, false), Op::Call(355, vec![6], 1, false), Op::Call(354, vec![5, 7], 1, false)], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(5), Block { ops: vec![Op::Call(352, vec![2], 1, false), Op::Call(352, vec![3], 1, false), Op::Call(355, vec![6], 1, false), Op::Call(354, vec![5, 7], 1, false)], ctrl: Ctrl::Return(6, vec![8]) }), (G::from_u64(6), Block { ops: vec![Op::Call(353, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(8), Block { ops: vec![Op::Call(352, vec![4], 1, false)], ctrl: Ctrl::Return(8, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_353() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(352, vec![1], 1, false), Op::Call(354, vec![3, 4], 1, false), Op::Call(352, vec![2], 1, false), Op::Call(355, vec![6], 1, false), Op::Call(354, vec![5, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_354() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_355() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 1)], ctrl: Ctrl::Return(1, vec![2]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_356() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_357() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 2)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(357, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(357, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![Op::Call(358, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(7, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(358, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(8, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Call(359, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(9, vec![7]) }), (G::from_u64(8), Block { ops: vec![Op::Call(357, vec![6, 1, 2], 1, false)], ctrl: Ctrl::Return(10, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 17, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_358() -> Function { + Function { body: Block { ops: vec![Op::Call(357, vec![0, 2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 5), Op::Add(3, 5), Op::Call(357, vec![1, 6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_359() -> Function { + Function { body: Block { ops: vec![Op::Call(357, vec![0, 3, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(357, vec![1, 3, 4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Add(4, 7), Op::Call(357, vec![2, 8, 9], 1, false)], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_360() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Call(356, vec![1, 2], 1, false), Op::Call(361, vec![0, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_361() -> Function { + Function { body: Block { ops: vec![Op::Call(362, vec![0], 1, false), Op::U32LessThan(2, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(801, vec![0, 2], 1, false), Op::Sub(1, 2), Op::Call(361, vec![4, 5], 1, false), Op::Add(2, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 10, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_362() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(352, vec![2], 1, false), Op::Call(363, vec![3, 5], 1, false), Op::Add(4, 6)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_363() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(362, vec![0], 1, false), Op::U32LessThan(2, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(801, vec![0, 2], 1, false), Op::Sub(1, 2), Op::Call(363, vec![4, 5], 1, false), Op::Add(2, 6)], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_364() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Call(356, vec![1, 4], 1, false), Op::Call(361, vec![0, 5], 1, false), Op::Call(800, vec![0, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 13, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_365() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Call(0, vec![2, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(366, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_366() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(0, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(3, vec![6]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(4294967295))], ctrl: Ctrl::Return(4, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(365, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(365, vec![4, 1], 1, false), Op::Call(356, vec![6, 7], 1, false)], ctrl: Ctrl::Return(6, vec![8]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(367, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(7, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(367, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(8, vec![6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(368, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(9, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(365, vec![5, 1], 1, false)], ctrl: Ctrl::Return(10, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_367() -> Function { + Function { body: Block { ops: vec![Op::Call(365, vec![0, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 4), Op::Call(365, vec![1, 5], 1, false), Op::Call(356, vec![3, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_368() -> Function { + Function { body: Block { ops: vec![Op::Call(365, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(365, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(356, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Call(365, vec![2, 8], 1, false), Op::Call(356, vec![6, 9], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_369() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(0, vec![2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(370, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![5]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_370() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(371, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(369, vec![4, 1, 2], 1, false), Op::Call(369, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(369, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(369, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(369, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(369, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(372, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(369, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_371() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 0, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Add(0, 1), Op::Store(vec![4, 5, 4, 4])], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_372() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(369, vec![0, 3, 4], 1, false), Op::Call(369, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(369, vec![2, 3, 9], 1, false), Op::Store(vec![5, 6, 7, 10])], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_373() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(0, vec![2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(374, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![5]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_374() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(4, 1), Op::Store(vec![8, 9, 8, 8])], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(373, vec![4, 1, 2], 1, false), Op::Call(373, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(4, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(373, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(373, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(373, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(373, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(6, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(373, vec![4, 1, 2], 1, false), Op::Call(373, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 10), Op::Call(373, vec![6, 1, 11], 1, false), Op::Store(vec![7, 8, 9, 12])], ctrl: Ctrl::Return(7, vec![13]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(373, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(9, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_375() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(375, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(375, vec![4, 1], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(376, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(376, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(5, vec![6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(377, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(375, vec![5, 1], 1, false)], ctrl: Ctrl::Return(7, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_376() -> Function { + Function { body: Block { ops: vec![Op::Call(375, vec![0, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 4), Op::Call(375, vec![1, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_377() -> Function { + Function { body: Block { ops: vec![Op::Call(375, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(375, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 6), Op::Call(375, vec![2, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_378() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(0, vec![2, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Call(375, vec![0, 2], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(379, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 6), Op::Call(373, vec![0, 6, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_379() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(380, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(378, vec![4, 1, 2], 1, false), Op::Call(378, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(378, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(378, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(378, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(378, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(381, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(378, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_380() -> Function { + Function { body: Block { ops: vec![Op::Call(0, vec![0, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 0, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(0, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(369, vec![1, 2, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(0, 6), Op::Store(vec![5, 7, 5, 5])], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_381() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(378, vec![0, 3, 4], 1, false), Op::Call(378, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(378, vec![2, 3, 9], 1, false), Op::Store(vec![5, 6, 7, 10])], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_382() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![1], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(0, vec![2, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Add(2, 3), Op::Call(357, vec![0, 2, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(384, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(2, 3), Op::Call(373, vec![0, 3, 8], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_383() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Sub(0, 2), Op::Call(0, vec![4, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(792, vec![1, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(369, vec![6, 2, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(0, 3), Op::Store(vec![6, 7, 6, 6])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_384() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(383, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 8, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(382, vec![4, 1, 2], 1, false), Op::Call(382, vec![5, 1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(382, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(382, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(4, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(382, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(382, vec![5, 1, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 11, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(385, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(382, vec![6, 1, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_385() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(382, vec![0, 3, 4], 1, false), Op::Call(382, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(382, vec![2, 3, 9], 1, false), Op::Store(vec![5, 6, 7, 10])], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_386() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 2]), Op::Call(386, vec![5, 9, 11], 3, false)], ctrl: Ctrl::Return(0, vec![12, 13, 14]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 2, 1]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 2, 1]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_387() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(386, vec![1, 0, 4], 3, false), Op::Call(790, vec![6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(266, vec![1, 0], 1, false)], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![6, 9], 1, false), Op::Call(378, vec![5, 10, 9], 1, false), Op::Call(388, vec![11, 7, 2], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(382, vec![5, 6, 9], 1, false), Op::Call(388, vec![10, 7, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_388() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(789, vec![8, 1], 1, false), Op::Call(388, vec![7, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(387, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(407, vec![4, 5, 0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![6, 5, 7], 1, false), Op::Call(388, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Call(389, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![0, 1], 1, false)], ctrl: Ctrl::Return(5, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_389() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![2, 4], 1, false), Op::Call(242, vec![5, 4], 1, false), Op::Call(125, vec![6], 2, false), Op::Call(396, vec![0, 1, 7, 8], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(388, vec![10, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 7)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(397, vec![7], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(6), Block { ops: vec![Op::Add(22, 1), Op::Call(792, vec![8, 28], 1, false), Op::Call(388, vec![29, 3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![28, 0, 1, 5]), Op::Call(266, vec![29, 3], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![15, 0, 1, 5]), Op::Call(266, vec![16, 3], 1, false)], ctrl: Ctrl::Return(3, vec![17]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 28, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_390() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(30)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(156)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(85)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 12, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_391() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(62)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(23)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 9, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_392() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(53)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(188)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 6, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 17, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_393() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(129)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(146)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(169)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 5, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_394() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(134)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(167)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(33)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 29])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_395() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(23)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(124)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(239)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 8, 10, 18, 6, 19, 20, 21, 17, 22, 23, 24, 24, 25, 26])], ctrl: Ctrl::Return(0, vec![27]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_396() -> Function { + Function { body: Block { ops: vec![Op::Call(390, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(391, vec![], 1, false), Op::Call(2, vec![7, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![3], 1, false), Op::Const(G::from_u64(5)), Op::U32LessThan(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![3, 15], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![3, 17], 1, false), Op::Const(G::from_u64(2)), Op::Call(792, vec![3, 19], 1, false), Op::Const(G::from_u64(3)), Op::Call(792, vec![3, 21], 1, false), Op::Const(G::from_u64(4)), Op::Call(792, vec![3, 23], 1, false), Op::Load(4, 18)], ctrl: Ctrl::Match(25, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 20)], ctrl: Ctrl::Match(29, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![33, 0, 1, 31]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![35, 30, 34, 36]), Op::Load(4, 22)], ctrl: Ctrl::Match(38, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![42, 0, 1, 40]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![44, 39, 43, 45]), Op::Const(G::from_u64(2)), Op::Call(392, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49]), Op::Store(vec![47, 48, 50, 45]), Op::Store(vec![44, 26, 51, 45]), Op::Store(vec![47, 7, 8, 45]), Op::Const(G::from_u64(3)), Op::Store(vec![54, 53, 16, 45]), Op::Store(vec![54, 55, 52, 45]), Op::Store(vec![54, 56, 37, 45]), Op::Store(vec![54, 57, 46, 45]), Op::Store(vec![54, 58, 24, 45]), Op::Const(G::from_u64(5)), Op::Call(801, vec![3, 60], 1, false), Op::Call(266, vec![59, 61], 1, false)], ctrl: Ctrl::Return(3, vec![49, 62]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![42, 42, 42, 42])], ctrl: Ctrl::Return(4, vec![42, 43]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![33, 33, 33, 33])], ctrl: Ctrl::Return(5, vec![33, 34]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![29, 29, 29, 29])], ctrl: Ctrl::Return(6, vec![29, 30]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(7, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(8, vec![6, 7]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 52, lookups: 37 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_397() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![2], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![6, 7, 5, 5]), Op::Store(vec![5, 5, 8, 5, 5, 5, 5, 5, 5, 5, 5, 5])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_398() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(428, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Call(398, vec![4, 1], 1, false), Op::Store(vec![6, 5, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_399() -> Function { + Function { body: Block { ops: vec![Op::Call(398, vec![1, 2], 1, false), Op::Call(790, vec![3], 1, false), Op::Call(160, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false), Op::Call(159, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![3, 11], 1, false), Op::Call(254, vec![12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(801, vec![3, 15], 1, false), Op::Call(126, vec![14], 1, false), Op::Call(256, vec![17], 1, false), Op::Call(266, vec![18, 16], 1, false)], ctrl: Ctrl::Return(1, vec![15, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(2, vec![15, 16]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(3, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![3, 11], 1, false), Op::Call(254, vec![12], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(801, vec![3, 15], 1, false), Op::Call(136, vec![14], 1, false), Op::Call(133, vec![17], 1, false), Op::Call(256, vec![18], 1, false), Op::Call(266, vec![19, 16], 1, false)], ctrl: Ctrl::Return(4, vec![15, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(5, vec![15, 16]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(275, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Return(6, vec![9, 10]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 23, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_400() -> Function { + Function { body: Block { ops: vec![Op::Call(398, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(0), Block { ops: vec![Op::Call(125, vec![7], 2, false), Op::Call(398, vec![10, 1], 1, false), Op::Call(266, vec![9, 11], 1, false), Op::Call(428, vec![4, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 12, 8]), Op::Store(vec![14, 13, 15])], ctrl: Ctrl::Return(2, vec![16]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_401() -> Function { + Function { body: Block { ops: vec![Op::Call(159, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(160, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(174, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(175, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(179, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(178, vec![], 1, false), Op::Call(2, vec![0, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(6, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![], 1, false), Op::Call(2, vec![0, 15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(7, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![], 1, false), Op::Call(2, vec![0, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(8, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(185, vec![], 1, false), Op::Call(2, vec![0, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(9, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(186, vec![], 1, false), Op::Call(2, vec![0, 21], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(10, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(180, vec![], 1, false), Op::Call(2, vec![0, 23], 1, false)], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(11, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(181, vec![], 1, false), Op::Call(2, vec![0, 25], 1, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(12, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(182, vec![], 1, false), Op::Call(2, vec![0, 27], 1, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(13, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(183, vec![], 1, false), Op::Call(2, vec![0, 29], 1, false)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(14, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(184, vec![], 1, false), Op::Call(2, vec![0, 31], 1, false)], ctrl: Ctrl::Match(32, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(15, vec![33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(16, vec![33]) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) }))) })), 1, 46, 30, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(230, vec![0], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(18, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(208, vec![0], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(19, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(195, vec![0], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(20, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(536, vec![0], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(21, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(253, vec![0], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(22, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![9]) }))) }))) }))) }))) }))) }))) })) }, layout: FunctionLayout { input_size: 1, selectors: 24, auxiliaries: 61, lookups: 38 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_402() -> Function { + Function { body: Block { ops: vec![Op::Call(401, vec![0], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(399, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(0, vec![5, 6]) }), (G::from_u64(2), Block { ops: vec![Op::Call(398, vec![2, 3], 1, false), Op::Call(231, vec![0, 5, 3], 2, false)], ctrl: Ctrl::Return(1, vec![6, 7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(214, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(2, vec![5, 6]) }), (G::from_u64(4), Block { ops: vec![Op::Call(198, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(3, vec![5, 6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(542, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(4, vec![5, 6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(264, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(5, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(6, vec![5, 6]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_403() -> Function { + Function { body: Block { ops: vec![Op::Call(394, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(404, vec![1, 2], 2, false)], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(395, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(405, vec![1, 2], 2, false)], ctrl: Ctrl::Return(1, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(2, vec![7, 8]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_404() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(6)), Op::U32LessThan(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(792, vec![0, 5], 1, false), Op::Const(G::from_u64(5)), Op::Call(792, vec![0, 7], 1, false), Op::Call(406, vec![8, 1], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(801, vec![0, 11], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![14, 6, 10, 15]), Op::Call(266, vec![16, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 16, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_405() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(5)), Op::U32LessThan(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(792, vec![0, 5], 1, false), Op::Const(G::from_u64(4)), Op::Call(792, vec![0, 7], 1, false), Op::Call(406, vec![8, 1], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(801, vec![0, 11], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![14, 6, 10, 15]), Op::Call(266, vec![16, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 16, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_406() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![0, 1], 1, false), Op::Call(125, vec![2], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(393, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![4], 1, false), Op::Const(G::from_u64(3)), Op::Sub(11, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(792, vec![4, 15], 1, false)], ctrl: Ctrl::Return(0, vec![14, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(1, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(3, vec![9, 10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 13, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_407() -> Function { + Function { body: Block { ops: vec![Op::Call(402, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(428, vec![6, 4], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(408, vec![11, 3], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(428, vec![21, 4], 1, false)], ctrl: Ctrl::Return(2, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(347, vec![11, 1], 1, false), Op::Call(388, vec![22, 3, 4], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![20]) }), (G::from_u64(4), Block { ops: vec![Op::Call(403, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(428, vec![21, 4], 1, false)], ctrl: Ctrl::Return(5, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(6, vec![22]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Add(11, 13), Op::Add(20, 14), Op::Add(21, 12)], ctrl: Ctrl::MatchContinue(16, [(G::from_u64(1), Block { ops: vec![Op::Call(419, vec![10, 22], 2, false), Op::Call(411, vec![1, 3, 11, 13, 14, 12, 15, 24, 4], 2, false)], ctrl: Ctrl::Yield(7, vec![25, 26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(8, vec![23, 2]) })), 2, 4, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(645, vec![10, 11, 13, 14, 12], 1, false), Op::Call(415, vec![1, 3, 11, 13, 14, 12, 15, 4, 2, 25], 2, false)], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![Op::Call(428, vec![27, 4], 1, false)], ctrl: Ctrl::Return(10, vec![28]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(11, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(418, vec![10, 1, 3, 11, 13, 14, 12, 15, 4], 2, false)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Call(428, vec![29, 4], 1, false)], ctrl: Ctrl::Return(12, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(13, vec![27]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(14, vec![28]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(15, vec![20]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 32, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_408() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(409, vec![0, 2], 5, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::U32LessThan(8, 4)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(792, vec![1, 7], 1, false), Op::Const(G::from_u64(8)), Op::Store(vec![11, 5, 6, 10]), Op::Call(801, vec![1, 4], 1, false), Op::Const(G::from_u64(1)), Op::Call(266, vec![12, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Return(2, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 18, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_409() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(409, vec![4, 7], 5, false)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11, 12]) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(7, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Sub(12, 7)], ctrl: Ctrl::Return(1, vec![11, 1, 3, 4, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 11, 12, 11, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(3, vec![10, 10, 11, 10, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(4, vec![6, 6, 7, 6, 6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 17, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_410() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(144, vec![3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(158, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 9, 10])], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(136, vec![3], 1, false), Op::Call(133, vec![6], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 7, 9]), Op::Const(G::from_u64(2)), Op::Call(159, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13]), Op::Store(vec![11, 12, 14, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 15, 10, 9])], ctrl: Ctrl::Return(1, vec![17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 14, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_411() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 6)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(4, 5), Op::Add(3, 14), Op::Add(2, 15), Op::Call(790, vec![1], 1, false), Op::Call(0, vec![16, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(0, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(792, vec![1, 16], 1, false), Op::Call(412, vec![19, 10, 2, 7, 8], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![21, 21, 21, 21])], ctrl: Ctrl::Return(1, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(347, vec![12, 0], 1, false), Op::Add(3, 4), Op::Add(2, 22), Op::Call(800, vec![1, 23], 1, false), Op::Const(G::from_u64(1)), Op::Add(16, 25), Op::Call(801, vec![1, 26], 1, false), Op::Call(266, vec![21, 24], 1, false), Op::Call(266, vec![28, 27], 1, false), Op::Call(428, vec![29, 8], 1, false)], ctrl: Ctrl::Return(2, vec![25, 30]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 18, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_412() -> Function { + Function { body: Block { ops: vec![Op::Call(498, vec![0, 4], 1, false), Op::Call(428, vec![5, 4], 1, false), Op::Call(125, vec![6], 2, false), Op::Load(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![10, 3], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![10], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(576, vec![22, 23, 1], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![28, 27, 11, 29]), Op::Call(800, vec![8, 2], 1, false), Op::Call(266, vec![30, 31], 1, false), Op::Call(498, vec![32, 4], 1, false), Op::Call(449, vec![6, 33, 4], 1, false)], ctrl: Ctrl::Return(1, vec![34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![27]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![13]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 30, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_413() -> Function { + Function { body: Block { ops: vec![Op::Call(800, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 4), Op::Call(801, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4]), Op::Store(vec![7, 2, 8]), Op::Call(789, vec![3, 9], 1, false), Op::Call(789, vec![10, 6], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_414() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![0, 1], 1, false), Op::Call(125, vec![2], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![6], 1, false), Op::Load(12, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(347, vec![13, 7], 1, false), Op::Call(388, vec![22, 4, 1], 1, false), Op::Call(414, vec![23, 1], 1, false)], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 24, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_415() -> Function { + Function { body: Block { ops: vec![Op::Add(4, 5), Op::Add(3, 10), Op::Add(2, 11), Op::Call(790, vec![1], 1, false), Op::U32LessThan(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(273, vec![1, 2, 3, 4, 12], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![17, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(792, vec![1, 12], 1, false), Op::Call(270, vec![17], 1, false), Op::Call(414, vec![18, 7], 1, false), Op::Call(270, vec![19], 1, false), Op::Call(410, vec![20], 1, false), Op::Call(416, vec![21], 4, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Call(2, vec![24, 9], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![26], vec![27], Some("iota: major's constructor belongs to a different inductive".into())), Op::Call(417, vec![6, 23], 3, false)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Call(413, vec![1, 12, 19], 1, false), Op::Const(G::from_u64(2)), Op::Call(266, vec![8, 31], 1, false)], ctrl: Ctrl::Return(2, vec![32, 33]) }), (G::from_u64(1), Block { ops: vec![Op::Call(347, vec![30, 0], 1, false), Op::Add(3, 4), Op::Add(2, 32), Op::Call(800, vec![1, 33], 1, false), Op::Call(790, vec![25], 1, false), Op::Sub(35, 29), Op::Call(801, vec![25, 36], 1, false), Op::Const(G::from_u64(1)), Op::Add(12, 38), Op::Call(801, vec![1, 39], 1, false), Op::Call(266, vec![31, 34], 1, false), Op::Call(266, vec![41, 37], 1, false), Op::Call(266, vec![42, 40], 1, false)], ctrl: Ctrl::Return(3, vec![38, 43]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(413, vec![1, 12, 19], 1, false), Op::Const(G::from_u64(2)), Op::Call(266, vec![8, 26], 1, false)], ctrl: Ctrl::Return(4, vec![27, 28]) }))) }))) }))) }, layout: FunctionLayout { input_size: 10, selectors: 5, auxiliaries: 33, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_416() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(474, vec![11, 12], 1, false)], ctrl: Ctrl::Return(0, vec![20, 13, 21, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22])], ctrl: Ctrl::Return(1, vec![20, 20, 21, 23]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9])], ctrl: Ctrl::Return(2, vec![7, 7, 8, 10]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 23, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_417() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 7, 8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8, 4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(417, vec![6, 1], 3, false)], ctrl: Ctrl::Return(2, vec![8, 9, 10]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 10, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_418() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(0, vec![14, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Load(5, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(1, vec![19, 20]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(3, 4), Op::Add(19, 5), Op::Add(20, 6), Op::Call(419, vec![0, 21], 2, false)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![24, 24, 24, 24])], ctrl: Ctrl::Return(2, vec![24, 25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![23], 1, false), Op::Load(12, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(30, 37)], ctrl: Ctrl::Match(38, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(29, [(G::from_u64(0), Block { ops: vec![Op::Call(421, vec![23], 1, false)], ctrl: Ctrl::Match(39, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![40, 40, 40, 40])], ctrl: Ctrl::Return(3, vec![40, 41]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(792, vec![2, 21], 1, false), Op::Call(790, vec![8], 1, false), Op::Call(352, vec![40], 1, false), Op::Call(0, vec![41, 42], 1, false)], ctrl: Ctrl::Match(43, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![44, 44, 44, 44])], ctrl: Ctrl::Return(4, vec![44, 45]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(498, vec![40, 8], 1, false), Op::Call(480, vec![44, 8], 1, false)], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![46, 46, 46, 46])], ctrl: Ctrl::Return(5, vec![46, 47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(347, vec![12, 1], 1, false), Op::Add(3, 4), Op::Add(47, 5), Op::Call(800, vec![2, 48], 1, false), Op::Call(266, vec![46, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(420, vec![50, 23, 40, 11, 51], 1, false), Op::Const(G::from_u64(1)), Op::Add(21, 53), Op::Call(801, vec![2, 54], 1, false), Op::Call(266, vec![52, 55], 1, false)], ctrl: Ctrl::Return(6, vec![53, 56]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![39, 39, 39, 39])], ctrl: Ctrl::Return(7, vec![39, 40]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![39, 39, 39, 39])], ctrl: Ctrl::Return(8, vec![39, 40]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![37, 37, 37, 37])], ctrl: Ctrl::Return(9, vec![37, 38]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 10, auxiliaries: 43, lookups: 19 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_419() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(125, vec![3], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![12, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(2, vec![6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(419, vec![4, 7], 2, false)], ctrl: Ctrl::Return(3, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(4, vec![6, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 13, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_420() -> Function { + Function { body: Block { ops: vec![Op::Sub(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![6, 1, 4, 2]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 0, 7, 9]), Op::Const(G::from_u64(1)), Op::Add(4, 11), Op::Call(420, vec![10, 1, 2, 3, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_421() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(422, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(423, vec![9, 10, 7, 5, 14, 15], 1, false)], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 16, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_422() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![1], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Call(306, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![50]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Store(vec![50, 0, 52])], ctrl: Ctrl::Return(1, vec![53]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_423() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![0, 1, 5], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(6), Block { ops: vec![Op::Call(424, vec![10, 3], 1, false), Op::Call(425, vec![20, 4], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 22), Op::Call(423, vec![0, 1, 2, 3, 4, 23], 1, false)], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![20]) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 19, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_424() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(424, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_425() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(426, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(425, vec![4, 1], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_426() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(427, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(426, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(426, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Call(426, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![4, 1], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Call(426, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![4, 1], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![5, 1], 1, false)], ctrl: Ctrl::Return(9, vec![8]) }))) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(426, vec![5, 1], 1, false)], ctrl: Ctrl::Return(10, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 12, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_427() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(427, vec![0, 4], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_428() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(364, vec![1, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Call(388, vec![0, 9, 7], 1, false)], ctrl: Ctrl::Return(5, vec![10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_429() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(388, vec![0, 3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_430() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(352, vec![0], 1, false), Op::Call(364, vec![1, 8], 1, false), Op::Call(431, vec![0, 7, 9], 1, false)], ctrl: Ctrl::Return(5, vec![10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_431() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(789, vec![8, 1], 1, false), Op::Call(431, vec![7, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(386, vec![0, 1, 8], 3, false), Op::Call(790, vec![10], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(266, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![10, 13], 1, false), Op::Call(378, vec![9, 14, 13], 1, false), Op::Call(431, vec![15, 11, 2], 1, false)], ctrl: Ctrl::Return(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(382, vec![9, 10, 13], 1, false), Op::Call(431, vec![14, 11, 2], 1, false)], ctrl: Ctrl::Return(3, vec![15]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![6, 5, 7], 1, false), Op::Call(431, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Call(432, vec![4, 5, 6, 1, 2, 0], 1, false)], ctrl: Ctrl::Return(5, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(433, vec![4, 5, 0, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![0, 1], 1, false)], ctrl: Ctrl::Return(7, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_432() -> Function { + Function { body: Block { ops: vec![Op::Call(430, vec![2, 4], 1, false), Op::Call(125, vec![6], 2, false), Op::Load(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(397, vec![7], 1, false), Op::Load(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(6), Block { ops: vec![Op::Add(20, 1), Op::Call(792, vec![8, 26], 1, false), Op::Call(431, vec![27, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![5, 3], 1, false)], ctrl: Ctrl::Return(1, vec![26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![5, 3], 1, false)], ctrl: Ctrl::Return(2, vec![13]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 23, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_433() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(7), Block { ops: vec![Op::Call(645, vec![8, 9, 11, 12, 10], 1, false), Op::Call(415, vec![1, 3, 9, 11, 12, 10, 13, 4, 2, 18], 2, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Call(430, vec![20, 4], 1, false)], ctrl: Ctrl::Return(0, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 19, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_434() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(364, vec![1, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Call(436, vec![0, 9, 7], 1, false)], ctrl: Ctrl::Return(5, vec![10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_435() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(436, vec![0, 3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_436() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(789, vec![8, 1], 1, false), Op::Call(436, vec![7, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(437, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(439, vec![4, 5, 0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![6, 5, 7], 1, false), Op::Call(436, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(8), Block { ops: vec![Op::Call(438, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![0, 1], 1, false)], ctrl: Ctrl::Return(5, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_437() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(386, vec![1, 0, 4], 3, false), Op::Call(790, vec![6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(266, vec![1, 0], 1, false)], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![6, 9], 1, false), Op::Call(378, vec![5, 10, 9], 1, false), Op::Call(436, vec![11, 7, 2], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(382, vec![5, 6, 9], 1, false), Op::Call(436, vec![10, 7, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_438() -> Function { + Function { body: Block { ops: vec![Op::Call(434, vec![2, 4], 1, false), Op::Call(242, vec![5, 4], 1, false), Op::Call(125, vec![6], 2, false), Op::Call(396, vec![0, 1, 7, 8], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(436, vec![10, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 7)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(397, vec![7], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(6), Block { ops: vec![Op::Add(22, 1), Op::Call(792, vec![8, 28], 1, false), Op::Call(436, vec![29, 3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![28, 0, 1, 5]), Op::Call(266, vec![29, 3], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![15, 0, 1, 5]), Op::Call(266, vec![16, 3], 1, false)], ctrl: Ctrl::Return(3, vec![17]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 28, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_439() -> Function { + Function { body: Block { ops: vec![Op::Call(401, vec![0], 1, false)], ctrl: Ctrl::MatchContinue(5, [(G::from_u64(1), Block { ops: vec![Op::Call(266, vec![2, 3], 1, false), Op::Call(352, vec![6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(402, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Yield(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Yield(1, vec![8, 9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(402, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Yield(2, vec![6, 7]) })), 2, 4, 3, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![7, 4], 1, false)], ctrl: Ctrl::Return(3, vec![8]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(408, vec![12, 3], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![22, 4], 1, false)], ctrl: Ctrl::Return(5, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(6, vec![23]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(403, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![22, 4], 1, false)], ctrl: Ctrl::Return(7, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(8, vec![23]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Add(12, 14), Op::Add(21, 15), Op::Add(22, 13)], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(1), Block { ops: vec![Op::Call(419, vec![11, 23], 2, false), Op::Call(411, vec![1, 3, 12, 14, 15, 13, 16, 25, 4], 2, false)], ctrl: Ctrl::Yield(9, vec![26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![24, 2]) })), 2, 4, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(11, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(645, vec![11, 12, 14, 15, 13], 1, false), Op::Call(415, vec![1, 3, 12, 14, 15, 13, 16, 4, 2, 26], 2, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![28, 4], 1, false)], ctrl: Ctrl::Return(12, vec![29]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(13, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(418, vec![11, 1, 3, 12, 14, 15, 13, 16, 4], 2, false)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![30, 4], 1, false)], ctrl: Ctrl::Return(14, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(15, vec![28]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(16, vec![29]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, vec![2, 3], 1, false)], ctrl: Ctrl::Return(17, vec![21]) }))) }))) })) }, layout: FunctionLayout { input_size: 5, selectors: 18, auxiliaries: 37, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_440() -> Function { + Function { body: Block { ops: vec![Op::Call(792, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Const(G::from_u64(0)), Op::Call(369, vec![2, 4, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_441() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 8, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_442() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![2]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![2]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![2]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![2]) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Return(6, vec![2]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 8, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_443() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(364, vec![1, 2], 1, false), Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(792, vec![3, 5], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 9), Op::Const(G::from_u64(0)), Op::Call(369, vec![8, 10, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 9]), Op::Call(344, vec![10], 1, false), Op::Store(vec![8, 11, 9, 9])], ctrl: Ctrl::Return(1, vec![12]) }), (G::from_u64(2), Block { ops: vec![Op::Call(298, vec![5], 1, false), Op::Load(12, 8), Op::Call(441, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(790, vec![6], 1, false), Op::AssertEq(vec![22], vec![21], Some("Const applied to wrong number of universe levels".into())), Op::Call(442, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(347, vec![23, 6], 1, false)], ctrl: Ctrl::Return(2, vec![24]) }), (G::from_u64(3), Block { ops: vec![Op::Call(443, vec![5, 3], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![11, 6, 13], 1, false)], ctrl: Ctrl::Return(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![8, 3], 1, false), Op::Load(4, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![16, 6, 18], 1, false)], ctrl: Ctrl::Return(4, vec![19]) })].into_iter().collect(), None) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 3]), Op::Call(443, vec![6, 9], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![11, 5, 10, 8])], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(5), Block { ops: vec![Op::Call(445, vec![5, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 5, 3]), Op::Call(445, vec![6, 10], 1, false), Op::Const(G::from_u64(1)), Op::Call(343, vec![8, 11], 1, false), Op::Store(vec![12, 13, 9, 9])], ctrl: Ctrl::Return(6, vec![14]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![7, 6, 8], 1, false), Op::Call(443, vec![9, 3], 1, false)], ctrl: Ctrl::Return(7, vec![10]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(392, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 11, 12])], ctrl: Ctrl::Return(8, vec![13]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(229, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 11, 12])], ctrl: Ctrl::Return(9, vec![13]) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![Op::Call(443, vec![7, 3], 1, false), Op::Call(428, vec![8, 3], 1, false), Op::Call(125, vec![9], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![13], vec![5], Some("projection's structure type differs from the value's head".into())), Op::Call(298, vec![13], 1, false), Op::Load(12, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![22], vec![29], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(301, vec![24, 25, 30], 1, false), Op::Load(12, 31)], ctrl: Ctrl::Match(32, [(G::from_u64(6), Block { ops: vec![Op::Call(347, vec![34, 14], 1, false), Op::Call(446, vec![44, 11, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(447, vec![45, 6, 46, 5, 7], 1, false)], ctrl: Ctrl::Return(10, vec![47]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 44, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_444() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(792, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Const(G::from_u64(0)), Op::Call(369, vec![6, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 7]), Op::Call(344, vec![8], 1, false), Op::Store(vec![6, 9, 7, 7])], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(298, vec![3], 1, false), Op::Load(12, 6), Op::Call(441, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(790, vec![4], 1, false), Op::AssertEq(vec![20], vec![19], Some("Const applied to wrong number of universe levels".into())), Op::Call(442, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(347, vec![21, 4], 1, false)], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(443, vec![3, 1], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![9, 4, 11], 1, false)], ctrl: Ctrl::Return(3, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![6, 1], 1, false), Op::Load(4, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![14, 4, 16], 1, false)], ctrl: Ctrl::Return(4, vec![17]) })].into_iter().collect(), None) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 1]), Op::Call(443, vec![4, 7], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![9, 3, 8, 6])], ctrl: Ctrl::Return(5, vec![10]) }), (G::from_u64(5), Block { ops: vec![Op::Call(445, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 3, 1]), Op::Call(445, vec![4, 8], 1, false), Op::Const(G::from_u64(1)), Op::Call(343, vec![6, 9], 1, false), Op::Store(vec![10, 11, 7, 7])], ctrl: Ctrl::Return(6, vec![12]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![5, 4, 6], 1, false), Op::Call(443, vec![7, 1], 1, false)], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(392, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 9, 10])], ctrl: Ctrl::Return(8, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(229, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 9, 10])], ctrl: Ctrl::Return(9, vec![11]) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![Op::Call(443, vec![5, 1], 1, false), Op::Call(428, vec![6, 1], 1, false), Op::Call(125, vec![7], 2, false), Op::Load(4, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![11], vec![3], Some("projection's structure type differs from the value's head".into())), Op::Call(298, vec![11], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![27], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(301, vec![22, 23, 28], 1, false), Op::Load(12, 29)], ctrl: Ctrl::Match(30, [(G::from_u64(6), Block { ops: vec![Op::Call(347, vec![32, 12], 1, false), Op::Call(446, vec![42, 9, 18], 1, false), Op::Const(G::from_u64(0)), Op::Call(447, vec![43, 4, 44, 3, 5], 1, false)], ctrl: Ctrl::Return(10, vec![45]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 42, lookups: 13 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_445() -> Function { + Function { body: Block { ops: vec![Op::Call(443, vec![0, 1], 1, false), Op::Load(4, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![2, 1], 1, false), Op::Load(4, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_446() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(378, vec![5, 8, 10], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 12), Op::Call(446, vec![11, 9, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_447() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![10, 3, 2, 4]), Op::Const(G::from_u64(0)), Op::Call(378, vec![7, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 14), Op::Call(447, vec![13, 1, 15, 3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![16]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_448() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(335, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(448, vec![4, 7], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_449() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(352, vec![1], 1, false), Op::Call(354, vec![4, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(451, vec![0, 1, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(450, vec![0, 1, 2, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_450() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(365, vec![0, 4], 1, false), Op::Call(365, vec![1, 4], 1, false), Op::Call(356, vec![5, 6], 1, false), Op::Call(790, vec![2], 1, false), Op::Call(356, vec![7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(364, vec![2, 3], 1, false), Op::Call(451, vec![0, 1, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(373, vec![0, 9, 10], 1, false), Op::Call(373, vec![1, 9, 10], 1, false), Op::Call(801, vec![2, 9], 1, false), Op::Sub(3, 9), Op::Call(364, vec![13, 14], 1, false), Op::Call(451, vec![11, 12, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_451() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(452, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(452, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_452() -> Function { + Function { body: Block { ops: vec![Op::Call(453, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(460, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_453() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(125, vec![1], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Load(4, 5)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Sub(8, 12)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Call(448, vec![9, 13], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![4], 1, false), Op::Call(790, vec![6], 1, false), Op::Sub(17, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Call(454, vec![4, 6, 2], 1, false)], ctrl: Ctrl::Return(1, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![20]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_454() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::Call(449, vec![4, 7, 2], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(454, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_455() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(144, vec![3], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(158, vec![], 1, false), Op::Call(2, vec![2, 5], 1, false)], ctrl: Ctrl::Return(2, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_456() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]), Op::Call(256, vec![6], 1, false)], ctrl: Ctrl::Return(0, vec![5, 7, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(1, vec![5, 0, 7]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(159, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(456, vec![3], 3, false), Op::Const(G::from_u64(1)), Op::Call(126, vec![13], 1, false)], ctrl: Ctrl::Return(2, vec![14, 12, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(3, vec![11, 0, 13]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(173, vec![], 1, false), Op::Call(2, vec![10, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Call(456, vec![7], 3, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(128, vec![21, 17], 1, false)], ctrl: Ctrl::Return(4, vec![22, 20, 23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![22, 7, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(6, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20, 20, 20, 20, 20, 20, 20, 20])], ctrl: Ctrl::Return(7, vec![19, 0, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16, 16, 16])], ctrl: Ctrl::Return(8, vec![15, 0, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14, 14, 14, 14, 14, 14, 14, 14])], ctrl: Ctrl::Return(9, vec![13, 0, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(10, vec![9, 0, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(11, vec![5, 0, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 12, auxiliaries: 23, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_457() -> Function { + Function { body: Block { ops: vec![Op::Call(455, vec![0], 1, false), Op::Call(455, vec![1], 1, false), Op::Mul(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(456, vec![0], 3, false), Op::Call(456, vec![1], 3, false), Op::Mul(6, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![8, 11], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![14, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(449, vec![7, 10, 2], 1, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_458() -> Function { + Function { body: Block { ops: vec![Op::Call(459, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(459, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_459() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(239, vec![5], 1, false), Op::Call(241, vec![7, 2], 1, false), Op::Call(449, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_460() -> Function { + Function { body: Block { ops: vec![Op::Call(459, vec![0, 1, 2], 1, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(459, vec![1, 0, 2], 1, false)], ctrl: Ctrl::Yield(1, vec![4]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(461, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![5]) }))) })) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_461() -> Function { + Function { body: Block { ops: vec![Op::Call(430, vec![0, 2], 1, false), Op::Call(430, vec![1, 2], 1, false), Op::Sub(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(463, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(453, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(462, vec![0, 1, 3, 4, 2], 1, false)], ctrl: Ctrl::Return(3, vec![8]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_462() -> Function { + Function { body: Block { ops: vec![Op::Call(434, vec![2, 4], 1, false), Op::Call(434, vec![3, 4], 1, false), Op::Sub(5, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(463, vec![5, 6, 4], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(453, vec![5, 6, 4], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(464, vec![0, 1, 5, 6, 4], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_463() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(335, vec![4, 8], 1, false)], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![11]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(449, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(449, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(2, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![11]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(449, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(449, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(5, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_464() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(478, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(476, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(472, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(472, vec![3, 2, 4], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(457, vec![2, 3, 4], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Call(483, vec![2, 3, 12, 4], 3, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(465, vec![0, 1, 14, 15, 4], 1, false)], ctrl: Ctrl::Return(7, vec![16]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 18, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_465() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(469, vec![2, 3, 5, 4], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(467, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(471, vec![0, 1, 4], 1, false)], ctrl: Ctrl::Return(2, vec![9]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_466() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(125, vec![1], 2, false), Op::Call(790, vec![4], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![4], 1, false), Op::Call(790, vec![6], 1, false), Op::Sub(8, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(11, [(G::from_u64(8), Block { ops: vec![Op::Load(4, 5)], ctrl: Ctrl::Match(15, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![12, 16], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Sub(13, 17)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(449, vec![14, 18, 2], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(454, vec![4, 6, 2], 1, false)], ctrl: Ctrl::Return(1, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 20, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_467() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(469, vec![0, 1, 3, 2], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(466, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(468, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_468() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(3), Block { ops: vec![Op::Call(467, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(467, vec![5, 9, 2], 1, false)], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_469() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Sub(6, 10)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![14, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![14, 2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(3, vec![13, 14]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(335, vec![6, 10], 1, false)], ctrl: Ctrl::Return(4, vec![13, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(5, vec![13, 14]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![6, 10], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(448, vec![7, 11], 1, false)], ctrl: Ctrl::Return(6, vec![14, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(7, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(8, vec![13, 14]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(3), Block { ops: vec![Op::Call(469, vec![6, 10, 2, 3], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(469, vec![7, 11, 14, 3], 2, false)], ctrl: Ctrl::Return(9, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![15, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(11, vec![13, 14]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(4), Block { ops: vec![Op::Call(469, vec![6, 10, 2, 3], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 6, 3]), Op::Call(469, vec![7, 11, 14, 16], 2, false)], ctrl: Ctrl::Return(12, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![15, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(14, vec![13, 14]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Call(469, vec![6, 10, 2, 3], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 6, 3]), Op::Call(469, vec![7, 11, 14, 16], 2, false)], ctrl: Ctrl::Return(15, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![15, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(17, vec![13, 14]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(7), Block { ops: vec![Op::Call(351, vec![6, 7, 10, 11], 1, false)], ctrl: Ctrl::Return(18, vec![13, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(19, vec![13, 14]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![6, 10], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Sub(7, 11)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Call(469, vec![8, 12, 2, 3], 2, false)], ctrl: Ctrl::Return(20, vec![15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(21, vec![15, 2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(22, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(23, vec![13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(470, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(24, vec![9, 10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 25, auxiliaries: 16, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_470() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 4), Op::Call(434, vec![0, 3], 1, false), Op::Call(434, vec![1, 3], 1, false), Op::Sub(6, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(457, vec![6, 7, 3], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![10, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(483, vec![6, 7, 11, 3], 3, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![15, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(469, vec![13, 14, 5, 3], 2, false)], ctrl: Ctrl::Return(4, vec![15, 16]) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_471() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![0, 2], 1, false), Op::Call(428, vec![1, 2], 1, false), Op::Sub(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(478, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(476, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(472, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(472, vec![4, 3, 2], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(457, vec![3, 4, 2], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(475, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(481, vec![3, 4, 2], 1, false)], ctrl: Ctrl::Return(7, vec![13]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_472() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![1], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![6], 1, false), Op::Load(12, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(6), Block { ops: vec![Op::Call(790, vec![4], 1, false), Op::Add(16, 17), Op::Sub(22, 23)], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![Op::Call(300, vec![13, 14], 1, false), Op::Load(12, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(5), Block { ops: vec![Op::EqZero(30), Op::Const(G::from_u64(1)), Op::Sub(31, 39), Op::EqZero(40), Op::Mul(38, 41)], ctrl: Ctrl::Match(42, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![43]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(474, vec![13, 14], 1, false), Op::Call(421, vec![43], 1, false)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![45]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(443, vec![0, 2], 1, false), Op::Call(443, vec![1, 2], 1, false), Op::Call(449, vec![45, 46, 2], 1, false)], ctrl: Ctrl::Match(47, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![48]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(473, vec![43, 16, 17, 0, 4, 48, 2], 1, false)], ctrl: Ctrl::Return(3, vec![49]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![38]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![25]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 48, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_473() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 5)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![8, 0, 5, 3]), Op::Add(1, 5), Op::Call(792, vec![4, 10], 1, false), Op::Call(449, vec![9, 11, 6], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 13), Op::Call(473, vec![0, 1, 2, 3, 4, 14, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_474() -> Function { + Function { body: Block { ops: vec![Op::Call(304, vec![1], 8, false), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12]), Op::Call(79, vec![10, 2, 3, 4, 5, 6, 7, 8, 9, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13], 1, false), Op::Call(23, vec![14], 1, false)], ctrl: Ctrl::Return(0, vec![15]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_475() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(479, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(479, vec![8, 9, 0, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_476() -> Function { + Function { body: Block { ops: vec![Op::Call(443, vec![0, 2], 1, false), Op::Call(428, vec![3, 2], 1, false), Op::Call(477, vec![4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(443, vec![1, 2], 1, false), Op::Call(449, vec![3, 6, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_477() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(13, 20)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(301, vec![15, 16, 22], 1, false), Op::Load(12, 23)], ctrl: Ctrl::Match(24, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 34, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_478() -> Function { + Function { body: Block { ops: vec![Op::Call(443, vec![0, 2], 1, false), Op::Call(480, vec![3, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(443, vec![1, 2], 1, false), Op::Call(449, vec![3, 5, 2], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_479() -> Function { + Function { body: Block { ops: vec![Op::Call(443, vec![2, 3], 1, false), Op::Call(428, vec![4, 3], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(449, vec![0, 7, 3], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(369, vec![2, 11, 12], 1, false), Op::Store(vec![12, 12, 12, 12]), Op::Const(G::from_u64(3)), Op::Store(vec![15, 13, 14, 12]), Op::Store(vec![12, 0, 3]), Op::Call(449, vec![1, 16, 17], 1, false)], ctrl: Ctrl::Return(1, vec![18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![10]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 14, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_480() -> Function { + Function { body: Block { ops: vec![Op::Call(443, vec![0, 1], 1, false), Op::Call(428, vec![2, 1], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8]), Op::Call(335, vec![5, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_481() -> Function { + Function { body: Block { ops: vec![Op::Call(482, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_482() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Sub(4, 8)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![11]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(335, vec![4, 8], 1, false)], ctrl: Ctrl::Return(3, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![11]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(448, vec![5, 9], 1, false)], ctrl: Ctrl::Return(5, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(495, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(495, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(7, vec![11]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(3), Block { ops: vec![Op::Call(449, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(495, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(8, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(449, vec![5, 9, 2], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(495, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(9, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![13]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(495, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(11, vec![11]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(449, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(12, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(449, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(13, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(479, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(14, vec![11]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(449, vec![4, 8, 2], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(15, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 2]), Op::Call(449, vec![5, 9, 13], 1, false)], ctrl: Ctrl::Return(16, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(17, vec![11]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(18, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![Op::Call(351, vec![4, 5, 8, 9], 1, false)], ctrl: Ctrl::Return(19, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(410, vec![0], 1, false), Op::Sub(11, 0)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(20, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(482, vec![11, 1, 2], 1, false)], ctrl: Ctrl::Return(21, vec![13]) }))) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Sub(5, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(449, vec![6, 10, 2], 1, false)], ctrl: Ctrl::Return(22, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(24, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(25, vec![11]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 26, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_483() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5, 0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(457, vec![0, 1, 3], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![6, 0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(496, vec![0], 2, false), Op::Call(496, vec![1], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(485, vec![7, 9, 0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(3, vec![11, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(489, vec![7, 0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(4, vec![11, 12, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(490, vec![9, 0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(5, vec![11, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(491, vec![0, 1, 2, 3], 3, false)], ctrl: Ctrl::Return(6, vec![11, 12, 13]) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_484() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_485() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 6), Op::Call(298, vec![1], 1, false), Op::Load(12, 19), Op::Call(492, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(492, vec![20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], 1, false)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![34, 2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(487, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(1, vec![34, 35, 36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Call(486, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(2, vec![34, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(484, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(484, vec![20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], 1, false), Op::U32LessThan(35, 34)], ctrl: Ctrl::Match(36, [(G::from_u64(1), Block { ops: vec![Op::Call(486, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(3, vec![37, 38, 39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(34, 35)], ctrl: Ctrl::Match(37, [(G::from_u64(1), Block { ops: vec![Op::Call(487, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(4, vec![38, 39, 40]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(488, vec![2, 3, 4, 5], 3, false)], ctrl: Ctrl::Return(5, vec![38, 39, 40]) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 6, auxiliaries: 50, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_486() -> Function { + Function { body: Block { ops: vec![Op::Call(494, vec![0], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![5, 3], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Call(483, vec![6, 1, 8, 3], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6, 0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_487() -> Function { + Function { body: Block { ops: vec![Op::Call(494, vec![1], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![5, 3], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Call(483, vec![0, 6, 8, 3], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6, 0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_488() -> Function { + Function { body: Block { ops: vec![Op::Call(494, vec![0], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(494, vec![1], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(434, vec![5, 3], 1, false), Op::Call(434, vec![7, 3], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 10), Op::Call(483, vec![8, 9, 11, 3], 3, false)], ctrl: Ctrl::Return(0, vec![12, 13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8, 0, 1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![6, 0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_489() -> Function { + Function { body: Block { ops: vec![Op::Call(493, vec![2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(483, vec![1, 6, 8, 4], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 7), Op::Call(492, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![21, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(497, vec![1, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 23), Op::Call(483, vec![22, 2, 24, 4], 3, false)], ctrl: Ctrl::Return(2, vec![25, 26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![23, 1, 2]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_490() -> Function { + Function { body: Block { ops: vec![Op::Call(493, vec![1, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(483, vec![6, 2, 8, 4], 3, false)], ctrl: Ctrl::Return(0, vec![9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 7), Op::Call(492, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![21, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(497, vec![2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 23), Op::Call(483, vec![1, 22, 24, 4], 3, false)], ctrl: Ctrl::Return(2, vec![25, 26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![23, 1, 2]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_491() -> Function { + Function { body: Block { ops: vec![Op::Call(493, vec![0, 3], 2, false), Op::Call(493, vec![1, 3], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(483, vec![5, 7, 9, 3], 3, false)], ctrl: Ctrl::Return(0, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(483, vec![5, 1, 9, 3], 3, false)], ctrl: Ctrl::Return(1, vec![10, 11, 12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(483, vec![0, 7, 9, 3], 3, false)], ctrl: Ctrl::Return(2, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8, 0, 1]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_492() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 3, auxiliaries: 3, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_493() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Call(434, vec![0, 1], 1, false), Op::Call(125, vec![8], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(8), Block { ops: vec![Op::Call(494, vec![7], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![17, 5, 6, 16]), Op::Const(G::from_u64(1)), Op::Call(266, vec![18, 3], 1, false)], ctrl: Ctrl::Return(0, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![17, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![15, 8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8, 0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 18, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_494() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(298, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(347, vec![11, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(266, vec![20, 2], 1, false)], ctrl: Ctrl::Return(0, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(347, vec![11, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(266, vec![20, 2], 1, false)], ctrl: Ctrl::Return(1, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![20, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7, 0]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 22, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_495() -> Function { + Function { body: Block { ops: vec![Op::Call(496, vec![0], 2, false), Op::Call(496, vec![1], 2, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![3], 1, false), Op::Load(12, 7), Op::Call(298, vec![5], 1, false), Op::Load(12, 20), Op::Call(497, vec![0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2], 2, false), Op::Call(497, vec![1, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2], 2, false)], ctrl: Ctrl::Match(33, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![Op::Call(449, vec![34, 36, 2], 1, false)], ctrl: Ctrl::Return(2, vec![37]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(449, vec![34, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![37]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![Op::Call(449, vec![0, 36, 2], 1, false)], ctrl: Ctrl::Return(4, vec![37]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![37]) }))) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 39, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_496() -> Function { + Function { body: Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(1, vec![8, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_497() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Call(494, vec![0], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(434, vec![15, 13], 1, false)], ctrl: Ctrl::Return(0, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![16, 0]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(494, vec![0], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(434, vec![15, 13], 1, false)], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![16, 0]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![14, 0]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 5, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_498() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(500, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(499, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![3]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_499() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(365, vec![0, 3], 1, false), Op::Call(790, vec![1], 1, false), Op::Call(356, vec![4, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(364, vec![1, 2], 1, false), Op::Call(500, vec![0, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(373, vec![0, 6, 7], 1, false), Op::Call(801, vec![1, 6], 1, false), Op::Sub(2, 6), Op::Call(364, vec![9, 10], 1, false), Op::Call(500, vec![8, 11], 1, false), Op::Call(369, vec![12, 6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_500() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(792, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Const(G::from_u64(0)), Op::Call(369, vec![6, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 7]), Op::Call(344, vec![8], 1, false), Op::Store(vec![6, 9, 7, 7])], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(298, vec![3], 1, false), Op::Load(12, 6), Op::Call(441, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(790, vec![4], 1, false), Op::AssertEq(vec![20], vec![19], Some("Const applied to wrong number of universe levels".into())), Op::Call(442, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 1, false), Op::Call(347, vec![21, 4], 1, false)], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(498, vec![6, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(512, vec![8, 7, 10, 1], 1, false)], ctrl: Ctrl::Return(3, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Call(520, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 3, 1]), Op::Call(498, vec![4, 8], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![10, 3, 9, 7])], ctrl: Ctrl::Return(4, vec![11]) }), (G::from_u64(5), Block { ops: vec![Op::Call(520, vec![3, 1], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 3, 1]), Op::Call(520, vec![4, 8], 1, false), Op::Const(G::from_u64(1)), Op::Call(343, vec![6, 9], 1, false), Op::Store(vec![10, 11, 7, 7])], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(6), Block { ops: vec![Op::Call(501, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(7), Block { ops: vec![Op::Call(513, vec![3, 4], 1, false)], ctrl: Ctrl::Return(7, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(519, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(8, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_501() -> Function { + Function { body: Block { ops: vec![Op::Call(520, vec![0, 3], 1, false), Op::Call(521, vec![1, 0, 3], 0, false), Op::Call(790, vec![3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 5, 6, 6]), Op::Const(G::from_u64(2)), Op::Store(vec![8, 0, 1, 7, 5]), Op::Call(507, vec![2, 9, 3, 5], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_502() -> Function { + Function { body: Block { ops: vec![Op::Call(503, vec![0, 1], 2, false), Op::Sub(3, 5), Op::Const(G::from_u64(0)), Op::Call(369, vec![4, 6, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_503() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(440, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![7, 4]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(4, 7)], ctrl: Ctrl::Return(1, vec![3, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(503, vec![5, 8], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![3, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(503, vec![5, 8], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_504() -> Function { + Function { body: Block { ops: vec![Op::Call(505, vec![0, 1], 2, false), Op::Sub(2, 4), Op::Const(G::from_u64(0)), Op::Call(369, vec![3, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_505() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 1, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 4]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(1, vec![8, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(505, vec![5, 8], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(506, vec![4, 5, 6, 7], 1, false)], ctrl: Ctrl::Return(3, vec![8, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(505, vec![5, 8], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_506() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false), Op::Call(0, vec![3, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(0, vec![7, 3], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(7, 3), Op::Call(505, vec![1, 11], 2, false), Op::Sub(2, 13), Op::Const(G::from_u64(0)), Op::Call(369, vec![12, 14, 15], 1, false), Op::Call(369, vec![16, 3, 15], 1, false)], ctrl: Ctrl::Return(2, vec![17]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(506, vec![7, 1, 2, 3], 1, false), Op::Call(506, vec![8, 1, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 12, 13])], ctrl: Ctrl::Return(3, vec![14]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(506, vec![7, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Call(506, vec![8, 1, 2, 13], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 14, 15])], ctrl: Ctrl::Return(4, vec![16]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(506, vec![7, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Call(506, vec![8, 1, 2, 13], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 11, 14, 15])], ctrl: Ctrl::Return(5, vec![16]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(506, vec![7, 1, 2, 3], 1, false), Op::Call(506, vec![8, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 13), Op::Call(506, vec![9, 1, 2, 14], 1, false), Op::Store(vec![10, 11, 12, 15])], ctrl: Ctrl::Return(6, vec![16]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(506, vec![9, 1, 2, 3], 1, false), Op::Store(vec![10, 7, 8, 11])], ctrl: Ctrl::Return(7, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![0]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_507() -> Function { + Function { body: Block { ops: vec![Op::Call(352, vec![0], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Call(498, vec![0, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(3), Block { ops: vec![Op::Call(508, vec![1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(511, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(357, vec![0, 10, 9], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(511, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(509, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![12]) })].into_iter().collect(), None) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(511, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_508() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(2), Block { ops: vec![Op::Call(508, vec![4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_509() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(365, vec![0, 4], 1, false), Op::Call(510, vec![1, 5], 3, false), Op::Call(373, vec![0, 7, 4], 1, false), Op::Call(801, vec![2, 8], 1, false), Op::Sub(3, 8), Op::Call(511, vec![9, 6, 10, 11], 1, false), Op::Call(369, vec![12, 8, 4], 1, false)], ctrl: Ctrl::Return(0, vec![13]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_510() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![0, 2, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(510, vec![5, 8], 3, false), Op::Add(10, 7)], ctrl: Ctrl::Return(1, vec![9, 12, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(510, vec![5, 8], 3, false), Op::Add(10, 7), Op::Add(11, 7)], ctrl: Ctrl::Return(2, vec![9, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![0, 7, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_511() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(503, vec![1, 5], 2, false), Op::Sub(3, 9), Op::Const(G::from_u64(0)), Op::Call(369, vec![8, 10, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(506, vec![5, 1, 3, 8], 1, false), Op::Call(520, vec![9, 2], 1, false), Op::Store(vec![8, 9, 2]), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Store(vec![12, 9, 13, 1, 8]), Op::Call(507, vec![6, 14, 11, 13], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![16, 9, 15, 8])], ctrl: Ctrl::Return(1, vec![17]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(506, vec![5, 1, 3, 8], 1, false), Op::Call(520, vec![9, 2], 1, false), Op::Store(vec![8, 9, 2]), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Store(vec![12, 9, 13, 1, 8]), Op::Call(507, vec![6, 14, 11, 13], 1, false), Op::Call(428, vec![15, 11], 1, false), Op::Load(4, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(343, vec![10, 18], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![21, 22, 23, 23])], ctrl: Ctrl::Return(2, vec![24]) })].into_iter().collect(), None) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(506, vec![5, 1, 3, 8], 1, false), Op::Call(520, vec![9, 2], 1, false), Op::Call(507, vec![6, 1, 2, 3], 1, false), Op::Call(449, vec![11, 9, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("delayed let value type mismatch".into())), Op::Const(G::from_u64(2)), Op::Store(vec![14, 9, 6, 1, 3]), Op::Call(507, vec![7, 15, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![16]) }), (G::from_u64(3), Block { ops: vec![Op::Call(507, vec![5, 1, 2, 3], 1, false), Op::Call(428, vec![8, 2], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(507, vec![6, 1, 2, 3], 1, false), Op::Call(449, vec![14, 11, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15], vec![16], Some("delayed application type mismatch".into())), Op::Const(G::from_u64(0)), Op::Call(357, vec![12, 17, 16], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(373, vec![12, 19, 19], 1, false)], ctrl: Ctrl::Return(4, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(506, vec![6, 1, 3, 19], 1, false), Op::Call(378, vec![12, 20, 19], 1, false)], ctrl: Ctrl::Return(5, vec![21]) }))) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(506, vec![0, 1, 3, 8], 1, false), Op::Call(498, vec![9, 2], 1, false)], ctrl: Ctrl::Return(6, vec![10]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_512() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![2], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(382, vec![0, 2, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(790, vec![2], 1, false)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(382, vec![8, 2, 12], 1, false)], ctrl: Ctrl::Yield(3, vec![13]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(521, vec![5, 12, 3], 0, false), Op::Const(G::from_u64(0)), Op::Store(vec![13, 5, 2]), Op::Call(512, vec![9, 6, 14, 3], 1, false)], ctrl: Ctrl::Return(4, vec![15]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![2], 1, false)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(5, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(382, vec![0, 2, 12], 1, false)], ctrl: Ctrl::Yield(6, vec![13]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(428, vec![12, 3], 1, false), Op::Load(4, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Call(521, vec![5, 15, 3], 0, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Store(vec![18, 5, 20]), Op::Call(512, vec![16, 6, 21, 3], 1, false)], ctrl: Ctrl::Return(7, vec![22]) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 21, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_513() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(392, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 5, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(229, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 5, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_514() -> Function { + Function { body: Block { ops: vec![Op::Call(347, vec![0, 1], 1, false), Op::Call(515, vec![4, 2, 3], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10]), Op::Call(335, vec![7, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_515() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(428, vec![0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![0, 2], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 2]), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(515, vec![6, 11, 9], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![3]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_516() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(520, vec![1, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4]), Op::Call(335, vec![3, 5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![6], vec![7], Some("projection on a Prop structure: field is not a Prop".into()))], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_517() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(520, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Call(335, vec![4, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(352, vec![2], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![8], vec![9], Some("projection on a Prop structure: later fields depend on a data field".into()))], ctrl: Ctrl::Return(2, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_518() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(516, vec![5, 8, 6], 0, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(517, vec![5, 8, 9, 6], 0, false), Op::Const(G::from_u64(8)), Op::Store(vec![12, 3, 2, 4]), Op::Const(G::from_u64(0)), Op::Call(378, vec![9, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 16), Op::Call(518, vec![15, 1, 17, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![18]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_519() -> Function { + Function { body: Block { ops: vec![Op::Call(498, vec![2, 3], 1, false), Op::Call(428, vec![4, 3], 1, false), Op::Call(125, vec![5], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![9], vec![0], Some("projection's structure type differs from the value's head".into())), Op::Call(298, vec![9], 1, false), Op::Load(12, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![18], vec![25], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(301, vec![20, 21, 26], 1, false), Op::Load(12, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(6), Block { ops: vec![Op::Call(347, vec![30, 10], 1, false), Op::Call(446, vec![40, 7, 16], 1, false), Op::Add(16, 17), Op::Call(514, vec![15, 10, 42, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(518, vec![41, 1, 44, 0, 2, 43, 3], 1, false)], ctrl: Ctrl::Return(0, vec![45]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 39, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_520() -> Function { + Function { body: Block { ops: vec![Op::Call(498, vec![0, 1], 1, false), Op::Call(428, vec![2, 1], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_521() -> Function { + Function { body: Block { ops: vec![Op::Call(498, vec![0, 2], 1, false), Op::Call(449, vec![3, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], Some("inferred type is not def-eq to the expected type".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_522() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(123)), Op::Const(G::from_u64(182)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(39)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 7, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_523() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(241)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(244)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(177)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(145)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(87)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_524() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(175)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(176)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(150)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 20, 22, 23, 24, 25, 7, 26, 16, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_525() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(54)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(190)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(175)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(218)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 11, 16, 17, 18, 19, 20, 21, 16, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_526() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(140)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(170)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(233)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(161)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(75)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 18, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_527() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(92)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(111)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(132)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(104)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 2, 14, 15, 16, 17, 18, 19, 20, 21, 3, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_528() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(147)), Op::Const(G::from_u64(192)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(123)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(247)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(215)), Op::Const(G::from_u64(255)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(129)), Op::Const(G::from_u64(131)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 13, 19, 20, 21, 19, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_529() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(196)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(208)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(204)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(157)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(211)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 6, 18, 19, 5, 20, 21, 22, 12, 15, 23, 24, 16, 25, 26])], ctrl: Ctrl::Return(0, vec![27]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_530() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(106)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(202)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(253)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(221)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(211)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(166)), Op::Const(G::from_u64(250)), Op::Const(G::from_u64(222)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(164)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(150)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(173)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 4, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_531() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(230)), Op::Const(G::from_u64(235)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(180)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(168)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(236)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(203)), Op::Const(G::from_u64(185)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(248)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(164)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 12, 21, 0, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_532() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(212)), Op::Const(G::from_u64(148)), Op::Const(G::from_u64(220)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(134)), Op::Const(G::from_u64(186)), Op::Const(G::from_u64(142)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(198)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(246)), Op::Const(G::from_u64(206)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(213)), Op::Const(G::from_u64(254)), Op::Const(G::from_u64(251)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 3, 15, 3, 16, 17, 18, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_533() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(53)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(196)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(172)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(197)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(219)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(201)), Op::Const(G::from_u64(151)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(242)), Op::Const(G::from_u64(36)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 10, 11, 12, 13, 14, 15, 16, 17, 10, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_534() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(23)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(130)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(232)), Op::Const(G::from_u64(226)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(200)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(152)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(46)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_535() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(83)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(135)), Op::Const(G::from_u64(122)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(121)), Op::Const(G::from_u64(128)), Op::Const(G::from_u64(216)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(227)), Op::Const(G::from_u64(228)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(195)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(153)), Op::Const(G::from_u64(113)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(241)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(240)), Op::Const(G::from_u64(159)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 3, 15, 10, 16, 17, 14, 18, 19, 20, 21, 22, 23, 4, 24, 25, 5, 26])], ctrl: Ctrl::Return(0, vec![27]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_536() -> Function { + Function { body: Block { ops: vec![Op::Call(522, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(523, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(524, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(534, vec![], 1, false), Op::Call(2, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(533, vec![], 1, false), Op::Call(2, vec![0, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(535, vec![], 1, false), Op::Call(2, vec![0, 11], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![13]) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 19, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_537() -> Function { + Function { body: Block { ops: vec![Op::Call(534, vec![], 1, false), Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(533, vec![], 1, false), Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(535, vec![], 1, false), Op::Call(2, vec![0, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }))) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_538() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2), Block { ops: vec![Op::Call(161, vec![], 1, false), Op::Call(2, vec![6, 9], 1, false), Op::Call(162, vec![], 1, false), Op::Call(2, vec![6, 11], 1, false), Op::Add(10, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![14, 14, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(14, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![18, 12, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19])], ctrl: Ctrl::Return(2, vec![18, 18, 20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19])], ctrl: Ctrl::Return(3, vec![18, 18, 20]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(4, vec![9, 9, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6])], ctrl: Ctrl::Return(5, vec![5, 5, 7]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 20, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_539() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Call(161, vec![], 1, false)], ctrl: Ctrl::Yield(0, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(162, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![2]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Const(G::from_u64(0)), Op::Store(vec![3, 2, 5, 6]), Op::Const(G::from_u64(7)), Op::Store(vec![8, 6, 1, 6]), Op::Const(G::from_u64(3)), Op::Store(vec![10, 7, 9, 6])], ctrl: Ctrl::Return(2, vec![11]) })) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_540() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![2], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![2, 7], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![2, 9], 1, false), Op::Call(538, vec![8], 3, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(538, vec![10], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 17, 17, 17])], ctrl: Ctrl::Return(1, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(541, vec![0, 1, 2, 8, 10, 3], 2, false)], ctrl: Ctrl::Return(2, vec![17, 18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(541, vec![0, 1, 2, 8, 10, 3], 2, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 20, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_541() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![3, 5], 1, false), Op::Call(428, vec![4, 5], 1, false), Op::Call(538, vec![6], 3, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(538, vec![7], 3, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(539, vec![9, 10], 1, false), Op::Call(539, vec![12, 13], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![16, 0, 1, 17]), Op::Const(G::from_u64(3)), Op::Store(vec![19, 18, 14, 17]), Op::Store(vec![19, 20, 15, 17]), Op::Call(801, vec![2, 16], 1, false), Op::Const(G::from_u64(1)), Op::Call(266, vec![21, 22], 1, false)], ctrl: Ctrl::Return(0, vec![23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(1, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(2, vec![11, 12]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 16, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_542() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![2], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(537, vec![0], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(540, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(522, vec![], 1, false), Op::Call(2, vec![0, 8], 1, false), Op::Call(523, vec![], 1, false), Op::Call(2, vec![0, 10], 1, false), Op::Call(524, vec![], 1, false), Op::Call(2, vec![0, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(543, vec![1, 2, 3], 2, false)], ctrl: Ctrl::Return(2, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(544, vec![9, 11, 0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_543() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 5], 1, false), Op::Call(428, vec![4, 2], 1, false), Op::Call(254, vec![7], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![10, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(126, vec![9], 1, false), Op::Call(256, vec![10], 1, false), Op::Const(G::from_u64(2)), Op::Call(522, vec![], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 13, 0, 14]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 15, 11, 14]), Op::Store(vec![16, 17, 6, 14]), Op::Call(801, vec![1, 12], 1, false), Op::Const(G::from_u64(1)), Op::Call(266, vec![18, 19], 1, false)], ctrl: Ctrl::Return(1, vec![20, 21]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 14, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_544() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![4, 6], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![4, 8], 1, false), Op::Call(428, vec![7, 5], 1, false), Op::Call(428, vec![9, 5], 1, false), Op::Call(254, vec![10], 2, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(0, vec![14, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Call(254, vec![11], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(1, vec![16, 17]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(1), Block { ops: vec![Op::Call(135, vec![13, 15], 1, false)], ctrl: Ctrl::Yield(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![13, 15], 1, false)], ctrl: Ctrl::Yield(3, vec![16]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(545, vec![0, 1, 16, 7, 9, 2, 3, 4, 5], 2, false)], ctrl: Ctrl::Return(4, vec![17, 18]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 14, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_545() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(9, 2), Op::Mul(0, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12, 12])], ctrl: Ctrl::Return(0, vec![12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13]), Op::Store(vec![12, 14, 13]), Op::Store(vec![12, 12, 12]), Op::Store(vec![13, 15, 16]), Op::Const(G::from_u64(2)), Op::Call(532, vec![], 1, false), Op::Store(vec![18, 19, 17, 13]), Op::Call(531, vec![], 1, false), Op::Store(vec![18, 21, 16, 13])], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Call(187, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(188, vec![], 1, false)], ctrl: Ctrl::Yield(2, vec![23]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![25, 25, 25]), Op::Const(G::from_u64(0)), Op::Store(vec![24, 23, 26, 27]), Op::Const(G::from_u64(3)), Op::Store(vec![29, 20, 22, 27]), Op::Store(vec![29, 30, 28, 27])], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(527, vec![], 1, false)], ctrl: Ctrl::Yield(3, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(528, vec![], 1, false)], ctrl: Ctrl::Yield(4, vec![32]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(529, vec![], 1, false)], ctrl: Ctrl::Yield(5, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(530, vec![], 1, false)], ctrl: Ctrl::Yield(6, vec![32]) }))) })), 1, 3, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![34, 34, 34]), Op::Const(G::from_u64(0)), Op::Store(vec![33, 32, 35, 36]), Op::Const(G::from_u64(3)), Op::Store(vec![38, 37, 3, 36]), Op::Store(vec![38, 39, 4, 36]), Op::Store(vec![38, 40, 31, 36]), Op::Call(548, vec![2, 41, 5, 6, 7, 8], 2, false)], ctrl: Ctrl::Return(7, vec![42, 43]) })) })) }))) }, layout: FunctionLayout { input_size: 9, selectors: 8, auxiliaries: 29, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_546() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![1], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![1, 6], 1, false), Op::Const(G::from_u64(1)), Op::Call(792, vec![1, 8], 1, false), Op::Load(4, 7)], ctrl: Ctrl::Match(10, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(350, vec![12, 16], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(1, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(547, vec![12, 0, 1, 2], 2, false)], ctrl: Ctrl::Return(2, vec![19, 20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(3, vec![18, 19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(4, vec![18, 19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(5, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14, 14])], ctrl: Ctrl::Return(6, vec![14, 15]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 23, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_547() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 6, 5]), Op::Store(vec![4, 4, 4]), Op::Store(vec![5, 7, 8]), Op::Const(G::from_u64(2)), Op::Call(532, vec![], 1, false), Op::Store(vec![10, 11, 9, 5]), Op::Call(229, vec![], 1, false), Op::Store(vec![10, 13, 8, 5]), Op::Const(G::from_u64(7)), Op::Store(vec![15, 4, 0, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 12, 14, 5]), Op::Store(vec![17, 18, 16, 5]), Op::Store(vec![10, 1, 8, 5]), Op::Call(800, vec![2, 10], 1, false), Op::Call(266, vec![20, 21], 1, false), Op::Call(498, vec![22, 3], 1, false), Op::Call(428, vec![23, 3], 1, false), Op::Call(125, vec![24], 2, false), Op::Call(790, vec![26], 1, false), Op::U32LessThan(27, 4)], ctrl: Ctrl::Match(28, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![29, 29, 29, 29])], ctrl: Ctrl::Return(0, vec![29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![26, 29], 1, false), Op::Const(G::from_u64(2)), Op::Call(525, vec![], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![33, 33, 33]), Op::Store(vec![31, 32, 34, 29]), Op::Const(G::from_u64(3)), Op::Store(vec![36, 35, 30, 29]), Op::Store(vec![36, 37, 19, 29]), Op::Call(801, vec![2, 31], 1, false), Op::Call(266, vec![38, 39], 1, false)], ctrl: Ctrl::Return(1, vec![33, 40]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 35, lookups: 33 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_548() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(1), Block { ops: vec![Op::Call(525, vec![], 1, false)], ctrl: Ctrl::Yield(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(526, vec![], 1, false)], ctrl: Ctrl::Yield(1, vec![6]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 2, 3, 8]), Op::Call(800, vec![4, 7], 1, false), Op::Call(266, vec![9, 10], 1, false), Op::Call(498, vec![11, 5], 1, false), Op::Call(428, vec![12, 5], 1, false), Op::Call(125, vec![13], 2, false), Op::Call(790, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::U32LessThan(16, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(2, vec![19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(792, vec![15, 19], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22]), Op::Store(vec![21, 6, 23, 19]), Op::Const(G::from_u64(3)), Op::Store(vec![25, 24, 20, 19]), Op::Store(vec![25, 26, 1, 19]), Op::Call(801, vec![4, 21], 1, false), Op::Call(266, vec![27, 28], 1, false)], ctrl: Ctrl::Return(3, vec![22, 29]) }))) })) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 26, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_549() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_550() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_551() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 1]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_552() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_553() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 1]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_554() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Mul(1, 3)], ctrl: Ctrl::Return(0, vec![2, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0, 1]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_555() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0, 1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_556() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Load(32, 1), Op::Call(557, vec![2, 3, 4, 5, 34, 35, 36, 37], 1, false), Op::Call(557, vec![6, 7, 8, 9, 38, 39, 40, 41], 1, false), Op::Call(557, vec![10, 11, 12, 13, 42, 43, 44, 45], 1, false), Op::Call(557, vec![14, 15, 16, 17, 46, 47, 48, 49], 1, false), Op::Call(557, vec![18, 19, 20, 21, 50, 51, 52, 53], 1, false), Op::Call(557, vec![22, 23, 24, 25, 54, 55, 56, 57], 1, false), Op::Call(557, vec![26, 27, 28, 29, 58, 59, 60, 61], 1, false), Op::Call(557, vec![30, 31, 32, 33, 62, 63, 64, 65], 1, false), Op::Call(550, vec![72, 73], 1, false), Op::Call(550, vec![71, 74], 1, false), Op::Call(550, vec![70, 75], 1, false), Op::Call(550, vec![69, 76], 1, false), Op::Call(550, vec![68, 77], 1, false), Op::Call(550, vec![67, 78], 1, false), Op::Call(550, vec![66, 79], 1, false)], ctrl: Ctrl::Return(0, vec![80]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 80, lookups: 18 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_557() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(16777216)), Op::Mul(0, 8), Op::Const(G::from_u64(65536)), Op::Mul(1, 10), Op::Const(G::from_u64(256)), Op::Mul(2, 12), Op::Add(13, 3), Op::Add(11, 14), Op::Add(9, 15), Op::Mul(4, 8), Op::Mul(5, 10), Op::Mul(6, 12), Op::Add(19, 7), Op::Add(18, 20), Op::Add(17, 21), Op::Call(549, vec![16, 22], 1, false)], ctrl: Ctrl::Return(0, vec![23]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_558() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![0, 3], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 4)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(558, vec![0, 5], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_559() -> Function { + Function { body: Block { ops: vec![Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(558, vec![0, 2], 1, false), Op::Call(558, vec![1, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(556, vec![0, 1], 1, false), Op::Call(555, vec![6], 2, false)], ctrl: Ctrl::Return(1, vec![7, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(2, vec![6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(3, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(549, vec![4, 5], 1, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![6, 7]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_560() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Call(560, vec![3, 6], 1, false)], ctrl: Ctrl::Return(3, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(6, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(560, vec![3, 6], 1, false), Op::Call(560, vec![4, 7], 1, false), Op::Call(550, vec![8, 9], 1, false)], ctrl: Ctrl::Return(7, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(9, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(11, vec![8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(560, vec![3, 6], 1, false), Op::Call(560, vec![4, 7], 1, false), Op::Call(550, vec![8, 9], 1, false)], ctrl: Ctrl::Return(12, vec![10]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(4), Block { ops: vec![Op::Call(549, vec![3, 6], 1, false)], ctrl: Ctrl::Return(14, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(15, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 16, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_561() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(560, vec![3, 6], 1, false), Op::Call(561, vec![4, 7], 1, false), Op::Call(550, vec![8, 9], 1, false)], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_562() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(563, vec![1, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(1), Block { ops: vec![Op::Call(566, vec![1, 3], 1, false)], ctrl: Ctrl::Return(3, vec![4]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_563() -> Function { + Function { body: Block { ops: vec![Op::Call(133, vec![0], 1, false), Op::Call(133, vec![1], 1, false), Op::Call(793, vec![2], 1, false), Op::Call(793, vec![3], 1, false), Op::Call(549, vec![4, 5], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(564, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_564() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(564, vec![11, 21], 1, false), Op::Call(565, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Call(550, vec![22, 23], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 24, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_565() -> Function { + Function { body: Block { ops: vec![Op::Call(549, vec![7, 15], 1, false), Op::Call(549, vec![6, 14], 1, false), Op::Call(549, vec![5, 13], 1, false), Op::Call(549, vec![4, 12], 1, false), Op::Call(549, vec![3, 11], 1, false), Op::Call(549, vec![2, 10], 1, false), Op::Call(549, vec![1, 9], 1, false), Op::Call(549, vec![0, 8], 1, false), Op::Call(550, vec![22, 23], 1, false), Op::Call(550, vec![21, 24], 1, false), Op::Call(550, vec![20, 25], 1, false), Op::Call(550, vec![19, 26], 1, false), Op::Call(550, vec![18, 27], 1, false), Op::Call(550, vec![17, 28], 1, false), Op::Call(550, vec![16, 29], 1, false)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_566() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(549, vec![3, 6], 1, false), Op::Call(566, vec![4, 7], 1, false), Op::Call(550, vec![8, 9], 1, false)], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_567() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0), Op::Load(4, 1), Op::Call(568, vec![4, 5, 6, 7, 8, 9, 10, 11, 2], 2, false)], ctrl: Ctrl::Return(1, vec![12, 13]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_568() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(549, vec![1, 5], 1, false), Op::Call(555, vec![9], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(2, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(560, vec![1, 5], 1, false), Op::Call(555, vec![9], 2, false)], ctrl: Ctrl::Return(3, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(5, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(6, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(561, vec![2, 6], 1, false), Op::Call(555, vec![9], 2, false), Op::Call(559, vec![1, 5, 8], 2, false), Op::Call(554, vec![10, 11, 12, 13], 2, false)], ctrl: Ctrl::Return(7, vec![14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(8, vec![9, 10]) }))) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(9, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(10, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(11, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(567, vec![1, 5, 8], 2, false), Op::Call(567, vec![2, 6, 8], 2, false), Op::Call(554, vec![9, 10, 11, 12], 2, false)], ctrl: Ctrl::Return(12, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(13, vec![9, 10]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(14, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(15, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(16, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(17, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(567, vec![1, 5, 8], 2, false), Op::Call(567, vec![2, 6, 8], 2, false), Op::Call(554, vec![9, 10, 11, 12], 2, false)], ctrl: Ctrl::Return(18, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(19, vec![9, 10]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(20, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(21, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(22, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(23, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(24, vec![9, 10]) }), (G::from_u64(5), Block { ops: vec![Op::Call(567, vec![1, 5, 8], 2, false), Op::Call(567, vec![2, 6, 8], 2, false), Op::Call(554, vec![9, 10, 11, 12], 2, false)], ctrl: Ctrl::Return(25, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(26, vec![9, 10]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(27, vec![9, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(28, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(29, vec![9, 10]) }), (G::from_u64(3), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(30, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(31, vec![9, 10]) }), (G::from_u64(5), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(32, vec![9, 10]) }), (G::from_u64(6), Block { ops: vec![Op::Call(567, vec![1, 5, 8], 2, false), Op::Call(567, vec![2, 6, 8], 2, false), Op::Call(567, vec![3, 7, 8], 2, false), Op::Call(554, vec![11, 12, 13, 14], 2, false), Op::Call(554, vec![9, 10, 15, 16], 2, false)], ctrl: Ctrl::Return(33, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(34, vec![9, 10]) }))) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(35, vec![9, 10]) }), (G::from_u64(7), Block { ops: vec![Op::Call(562, vec![1, 2, 5, 6], 1, false), Op::Call(555, vec![9], 2, false)], ctrl: Ctrl::Return(36, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(37, vec![9, 10]) }))) }), (G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Call(559, vec![1, 5, 8], 2, false), Op::Call(549, vec![2, 6], 1, false), Op::Call(555, vec![11], 2, false), Op::Call(567, vec![3, 7, 8], 2, false), Op::Call(554, vec![12, 13, 14, 15], 2, false), Op::Call(554, vec![9, 10, 16, 17], 2, false)], ctrl: Ctrl::Return(38, vec![18, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(39, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 40, auxiliaries: 12, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_569() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(549, vec![1, 4], 1, false), Op::Call(555, vec![7], 2, false), Op::Call(567, vec![2, 5, 6], 2, false), Op::Call(554, vec![8, 9, 10, 11], 2, false)], ctrl: Ctrl::Return(0, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 1, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_570() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(5, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(551, vec![], 2, false)], ctrl: Ctrl::Return(1, vec![13, 14]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(5, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(553, vec![], 2, false)], ctrl: Ctrl::Return(2, vec![13, 14]) }), (G::from_u64(0), Block { ops: vec![Op::Call(569, vec![4, 5, 6, 9, 10, 11, 2], 2, false), Op::Call(570, vec![7, 12, 2], 2, false), Op::Call(554, vec![13, 14, 15, 16], 2, false)], ctrl: Ctrl::Return(3, vec![17, 18]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_571() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![12]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(6, vec![12]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(7, vec![12]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 8, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_572() -> Function { + Function { body: Block { ops: vec![Op::Call(571, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Call(571, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false), Op::Call(549, vec![25, 26], 1, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Call(573, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 2, false)], ctrl: Ctrl::Return(0, vec![28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(555, vec![27], 2, false)], ctrl: Ctrl::Return(1, vec![28, 29]) }))) }, layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_573() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(549, vec![1, 13], 1, false), Op::Call(555, vec![25], 2, false), Op::Call(567, vec![2, 14, 24], 2, false), Op::Call(567, vec![3, 15, 24], 2, false), Op::Call(554, vec![28, 29, 30, 31], 2, false), Op::Call(554, vec![26, 27, 32, 33], 2, false)], ctrl: Ctrl::Return(0, vec![34, 35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(1, vec![25, 26]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(5), Block { ops: vec![Op::Call(549, vec![6, 18], 1, false), Op::Call(555, vec![25], 2, false), Op::Call(549, vec![1, 13], 1, false), Op::Call(555, vec![28], 2, false), Op::Call(549, vec![3, 15], 1, false), Op::Call(555, vec![31], 2, false), Op::Call(549, vec![4, 16], 1, false), Op::Call(555, vec![34], 2, false), Op::Call(554, vec![32, 33, 35, 36], 2, false), Op::Call(554, vec![29, 30, 37, 38], 2, false), Op::Call(554, vec![26, 27, 39, 40], 2, false), Op::Call(549, vec![5, 17], 1, false)], ctrl: Ctrl::Match(43, [(G::from_u64(1), Block { ops: vec![Op::Call(567, vec![2, 14, 24], 2, false), Op::Const(G::from_u64(0)), Op::Call(574, vec![7, 8, 19, 20, 5, 24, 46], 2, false), Op::Call(554, vec![44, 45, 47, 48], 2, false), Op::Call(554, vec![41, 42, 49, 50], 2, false)], ctrl: Ctrl::Return(2, vec![51, 52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(555, vec![43], 2, false), Op::Call(554, vec![41, 42, 44, 45], 2, false)], ctrl: Ctrl::Return(3, vec![46, 47]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(4, vec![25, 26]) }))) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(7), Block { ops: vec![Op::Call(549, vec![1, 13], 1, false), Op::Call(555, vec![25], 2, false), Op::Call(549, vec![3, 15], 1, false), Op::Call(555, vec![28], 2, false), Op::Call(549, vec![4, 16], 1, false), Op::Call(555, vec![31], 2, false), Op::Call(549, vec![5, 17], 1, false), Op::Call(555, vec![34], 2, false), Op::Call(549, vec![6, 18], 1, false), Op::Call(555, vec![37], 2, false), Op::Call(549, vec![8, 20], 1, false), Op::Call(555, vec![40], 2, false), Op::Call(567, vec![2, 14, 24], 2, false), Op::Call(570, vec![7, 19, 24], 2, false), Op::Call(554, vec![43, 44, 45, 46], 2, false), Op::Call(554, vec![41, 42, 47, 48], 2, false), Op::Call(554, vec![38, 39, 49, 50], 2, false), Op::Call(554, vec![35, 36, 51, 52], 2, false), Op::Call(554, vec![32, 33, 53, 54], 2, false), Op::Call(554, vec![29, 30, 55, 56], 2, false), Op::Call(554, vec![26, 27, 57, 58], 2, false)], ctrl: Ctrl::Return(5, vec![59, 60]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(6, vec![25, 26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(7, vec![25, 26]) }))) }, layout: FunctionLayout { input_size: 25, selectors: 8, auxiliaries: 37, lookups: 22 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_574() -> Function { + Function { body: Block { ops: vec![Op::Sub(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(552, vec![], 2, false)], ctrl: Ctrl::Return(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![0, 1, 6], 1, false), Op::Load(12, 8), Op::Call(301, vec![2, 3, 6], 1, false), Op::Load(12, 21), Op::Call(575, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 5], 2, false), Op::Const(G::from_u64(1)), Op::Add(6, 36), Op::Call(574, vec![0, 1, 2, 3, 4, 5, 37], 2, false), Op::Call(554, vec![34, 35, 38, 39], 2, false)], ctrl: Ctrl::Return(1, vec![40, 41]) }))) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 34, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_575() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(6), Block { ops: vec![Op::Call(549, vec![1, 13], 1, false), Op::Call(555, vec![25], 2, false), Op::Call(549, vec![5, 17], 1, false), Op::Call(555, vec![28], 2, false), Op::Call(549, vec![6, 18], 1, false), Op::Call(555, vec![31], 2, false), Op::Call(549, vec![7, 19], 1, false), Op::Call(555, vec![34], 2, false), Op::Call(567, vec![2, 14, 24], 2, false), Op::Call(554, vec![35, 36, 37, 38], 2, false), Op::Call(554, vec![32, 33, 39, 40], 2, false), Op::Call(554, vec![29, 30, 41, 42], 2, false), Op::Call(554, vec![26, 27, 43, 44], 2, false)], ctrl: Ctrl::Return(0, vec![45, 46]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(571, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Call(571, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false), Op::Call(549, vec![25, 26], 1, false), Op::Call(555, vec![27], 2, false)], ctrl: Ctrl::Return(1, vec![28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(571, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Call(571, vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], 1, false), Op::Call(549, vec![25, 26], 1, false), Op::Call(555, vec![27], 2, false)], ctrl: Ctrl::Return(2, vec![28, 29]) }))) }, layout: FunctionLayout { input_size: 25, selectors: 3, auxiliaries: 23, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_576() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(304, vec![1], 8, false), Op::Call(304, vec![2], 8, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(79, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 22, 22, 22, 22], 1, false), Op::Call(23, vec![23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_577() -> Function { + Function { body: Block { ops: vec![Op::Call(792, vec![0, 1], 1, false), Op::Call(298, vec![2], 1, false), Op::Load(12, 3)], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_578() -> Function { + Function { body: Block { ops: vec![Op::Call(577, vec![0, 1], 12, false)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_579() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(790, vec![0], 1, false), Op::Call(580, vec![0, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_580() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::Call(581, vec![6, 1, 2, 3, 4], 2, false), Op::Const(G::from_u64(1)), Op::Add(3, 10), Op::Add(4, 9), Op::Call(580, vec![7, 1, 2, 11, 12], 1, false), Op::Call(785, vec![8, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_581() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(581, vec![7, 1, 2, 3, 4], 2, false), Op::Call(578, vec![1, 6], 1, false), Op::Const(G::from_u64(0)), Op::Call(582, vec![2, 6, 10, 4, 11], 1, false), Op::Call(792, vec![1, 6], 1, false), Op::Call(785, vec![12, 8], 1, false), Op::Store(vec![11, 13, 3, 14]), Op::U32LessThan(9, 10)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![15, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![15, 9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 18, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_582() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(576, vec![0, 1, 4], 1, false), Op::Add(3, 4), Op::Const(G::from_u64(1)), Op::Add(4, 9), Op::Call(582, vec![0, 1, 2, 3, 10], 1, false), Op::Store(vec![6, 7, 8, 11])], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_583() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![3, 0, 5]), Op::Call(790, vec![0], 1, false), Op::Add(4, 7), Op::Call(584, vec![6, 1, 2, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_584() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(790, vec![0], 1, false), Op::Call(580, vec![0, 1, 2, 4, 5], 1, false), Op::Call(585, vec![0, 6, 1], 1, false), Op::Call(591, vec![0, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 9), Op::Call(584, vec![7, 1, 2, 10], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_585() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(586, vec![4, 1, 2], 1, false), Op::Call(585, vec![5, 1, 2], 1, false), Op::Call(789, vec![6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_586() -> Function { + Function { body: Block { ops: vec![Op::Call(790, vec![0], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 0, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(587, vec![0, 1, 2], 1, false), Op::Call(589, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![5]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_587() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(587, vec![5, 1, 2], 1, false), Op::Call(588, vec![4, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_588() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![7, 0, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(577, vec![3, 0], 12, false), Op::Call(577, vec![3, 5], 12, false), Op::Call(572, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 2], 2, false)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![33, 0, 1])], ctrl: Ctrl::Return(1, vec![34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(588, vec![0, 6, 2, 3], 1, false), Op::Store(vec![33, 5, 34])], ctrl: Ctrl::Return(2, vec![35]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 33, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_589() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 4, 8]), Op::Call(590, vec![5, 1, 2, 4, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_590() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![8, 4, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(577, vec![2, 3], 12, false), Op::Call(577, vec![2, 6], 12, false), Op::Call(572, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1], 2, false)], ctrl: Ctrl::Match(32, [(G::from_u64(1), Block { ops: vec![Op::Call(783, vec![4, 6], 1, false), Op::Call(590, vec![7, 1, 2, 6, 34], 1, false)], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35]), Op::Store(vec![34, 6, 36]), Op::Call(590, vec![7, 1, 2, 6, 37], 1, false), Op::Store(vec![34, 4, 38])], ctrl: Ctrl::Return(2, vec![39]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 35, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_591() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(350, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(591, vec![4, 7], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_592() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(592, vec![3], 1, false), Op::Call(789, vec![2, 4], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_593() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(790, vec![2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(593, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_594() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![49, 49, 49])], ctrl: Ctrl::Return(0, vec![50]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 49), Op::Call(594, vec![48, 50], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![52, 1, 51])], ctrl: Ctrl::Return(1, vec![53]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![51]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 50, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_595() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![49]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(49, 1)], ctrl: Ctrl::Yield(2, vec![50]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(3, vec![49]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(49, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![50]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(595, vec![48, 1], 1, false)], ctrl: Ctrl::Return(5, vec![50]) }))) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 51, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_596() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(595, vec![2, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(595, vec![2, 51], 1, false), Op::Mul(50, 52), Op::AssertEq(vec![53], vec![51], Some("mutual block mixes a definition member with inductives".into())), Op::Call(594, vec![2, 51], 1, false), Op::Call(790, vec![54], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(55, 56)], ctrl: Ctrl::Match(57, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(306, vec![2, 0], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![60, 60, 60]), Op::Store(vec![59, 54, 61]), Op::Call(790, vec![54], 1, false), Op::Add(60, 63), Op::Call(584, vec![62, 58, 0, 64], 1, false), Op::Call(593, vec![65], 1, false), Op::AssertEq(vec![66], vec![60], Some("canonical block: refinement left members tied, order ambiguous".into())), Op::Call(592, vec![65], 1, false), Op::Call(350, vec![67, 54], 1, false), Op::AssertEq(vec![68], vec![60], Some("canonical block: members are not in canonical order".into()))], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 69, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_597() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![12]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![12]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![4]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![12]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(8, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_598() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(2), Block { ops: vec![Op::Call(298, vec![2], 1, false), Op::Load(12, 5), Op::Const(G::from_u64(1)), Op::Call(597, vec![6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Sub(18, 19)], ctrl: Ctrl::Return(2, vec![20]) }), (G::from_u64(3), Block { ops: vec![Op::Call(598, vec![2], 1, false), Op::Call(598, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(598, vec![2], 1, false), Op::Call(598, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(598, vec![2], 1, false), Op::Call(598, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(5, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Call(598, vec![2], 1, false), Op::Call(598, vec![3], 1, false), Op::Call(598, vec![4], 1, false), Op::Mul(6, 7), Op::Mul(5, 8)], ctrl: Ctrl::Return(6, vec![9]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(8), Block { ops: vec![Op::Call(598, vec![4], 1, false)], ctrl: Ctrl::Return(8, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 19, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_599() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(598, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("safe constant references an unsafe constant".into()))], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_600() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(600, vec![3, 1], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(600, vec![3, 1], 0, false), Op::Call(600, vec![4, 1], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(600, vec![3, 1], 0, false), Op::Call(600, vec![4, 1], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::U32LessThan(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("universe param index out of range".into()))], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_601() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(600, vec![3, 1], 0, false), Op::Call(601, vec![4, 1], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_602() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(4, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("loose bound variable: BVar index exceeds binder depth".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(600, vec![4, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(298, vec![4], 1, false), Op::Load(12, 7), Op::Call(441, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(790, vec![5], 1, false), Op::AssertEq(vec![21], vec![20], Some("Const applied to wrong number of universe levels".into())), Op::Call(601, vec![5, 2], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(602, vec![4, 1, 2], 0, false), Op::Call(602, vec![5, 1, 2], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Call(602, vec![4, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(602, vec![5, 8, 2], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Call(602, vec![4, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(602, vec![5, 8, 2], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Call(602, vec![4, 1, 2], 0, false), Op::Call(602, vec![5, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(602, vec![6, 8, 2], 0, false)], ctrl: Ctrl::Return(6, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![]) }), (G::from_u64(8), Block { ops: vec![Op::Call(602, vec![6, 1, 2], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 20, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_603() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(69)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(218)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(169)), Op::Const(G::from_u64(112)), Op::Const(G::from_u64(199)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(138)), Op::Const(G::from_u64(237)), Op::Const(G::from_u64(179)), Op::Const(G::from_u64(189)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(137)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(223)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(136)), Op::Const(G::from_u64(250)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 20, 29])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_604() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(195)), Op::Const(G::from_u64(125)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(144)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(184)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(251)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(183)), Op::Const(G::from_u64(188)), Op::Const(G::from_u64(225)), Op::Const(G::from_u64(143)), Op::Const(G::from_u64(214)), Op::Const(G::from_u64(158)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(173)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(234)), Op::Const(G::from_u64(159)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(120)), Op::Const(G::from_u64(162)), Op::Const(G::from_u64(7)), Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 6, 23, 24, 25, 26, 27, 28, 29, 30])], ctrl: Ctrl::Return(0, vec![31]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_605() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(605, vec![6, 1, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_606() -> Function { + Function { body: Block { ops: vec![Op::Call(604, vec![], 1, false), Op::Call(298, vec![0], 1, false), Op::Load(12, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![14], Some("Eq inductive: wrong universe param count".into())), Op::Const(G::from_u64(2)), Op::AssertEq(vec![5], vec![15], Some("Eq inductive: wrong parameter count".into())), Op::AssertEq(vec![7], vec![14], Some("Eq inductive: wrong constructor count".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_607() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![Op::Call(603, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.Typ declared at a non-canonical address".into())), Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(0, vec![6, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Call(393, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.mk declared at a non-canonical address".into())), Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(1, vec![6, 7]) }), (G::from_u64(2), Block { ops: vec![Op::Call(394, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.lift declared at a non-canonical address".into())), Op::Call(606, vec![], 0, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(6))], ctrl: Ctrl::Yield(2, vec![7, 8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(395, vec![], 1, false), Op::Call(2, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("Quot.ind declared at a non-canonical address".into())), Op::Const(G::from_u64(5))], ctrl: Ctrl::Yield(3, vec![6, 7]) })].into_iter().collect(), None, 2, 2, 3, Box::new(Block { ops: vec![Op::AssertEq(vec![2], vec![4], Some("Quot constant: wrong universe param count for its kind".into())), Op::Const(G::from_u64(0)), Op::Call(605, vec![3, 5, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("Quot constant: type has too few foralls for its kind".into()))], ctrl: Ctrl::Return(4, vec![]) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_608() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(608, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_609() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(790, vec![0], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![3], vec![4], Some("more universe levels than the inductive declares".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(4), Block { ops: vec![Op::AssertEq(vec![7], vec![2], Some("ctor return type: universe level is not Param(i) in order".into())), Op::Const(G::from_u64(1)), Op::Sub(1, 9), Op::Add(2, 9), Op::Call(609, vec![5, 10, 11], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_610() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Add(2, 1), Op::Const(G::from_u64(1)), Op::Sub(12, 13), Op::Sub(14, 3), Op::AssertEq(vec![9], vec![15], Some("ctor return type: param arg is not the expected param BVar".into())), Op::Add(3, 13), Op::Call(610, vec![7, 1, 2, 16], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_611() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![11, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], Some("ctor return head belongs to a different block".into())), Op::AssertEq(vec![12], vec![2], Some("ctor return head is a different member of the block".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_612() -> Function { + Function { body: Block { ops: vec![Op::Add(1, 3), Op::Call(608, vec![0, 7], 1, false), Op::Call(125, vec![8], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(611, vec![12, 5, 6], 0, false), Op::Const(G::from_u64(0)), Op::Call(609, vec![13, 4, 15], 0, false), Op::Call(790, vec![10], 1, false), Op::Add(1, 2), Op::AssertEq(vec![16], vec![17], Some("ctor return type: wrong number of spine arguments".into())), Op::Call(610, vec![10, 1, 3, 15], 0, false), Op::Call(801, vec![10, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Store(vec![15, 5, 20]), Op::Call(623, vec![18, 21], 1, false), Op::AssertEq(vec![22], vec![15], Some("ctor return type: reflexive occurrence in an index argument".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 1, auxiliaries: 13, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_613() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Call(449, vec![5, 9, 3], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("ctor parameter type disagrees with the inductive's".into())), Op::Const(G::from_u64(0)), Op::Store(vec![14, 5, 3]), Op::Sub(2, 13), Op::Call(613, vec![6, 10, 16, 15], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_614() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(613, vec![0, 1, 2, 4], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_615() -> Function { + Function { body: Block { ops: vec![Op::Call(428, vec![0, 2], 1, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Const(G::from_u64(0)), Op::Store(vec![10, 5, 2]), Op::Call(615, vec![6, 9, 11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_616() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Call(520, vec![4, 2], 1, false), Op::Call(334, vec![7, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], Some("ctor field lives in a universe above the inductive's".into())), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 2]), Op::Call(616, vec![5, 1, 11], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_617() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(616, vec![0, 2, 3], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Const(G::from_u64(0)), Op::Store(vec![10, 5, 3]), Op::Call(617, vec![6, 9, 2, 11], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_618() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(617, vec![0, 1, 2, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_619() -> Function { + Function { body: Block { ops: vec![Op::Call(300, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_620() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![3, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(620, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_621() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Call(620, vec![1, 10], 1, false)], ctrl: Ctrl::Return(0, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![15]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_622() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(2), Block { ops: vec![Op::Call(621, vec![3, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(622, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(622, vec![4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(622, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(622, vec![4, 1], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Call(622, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(622, vec![4, 1], 1, false)], ctrl: Ctrl::Return(8, vec![7]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Call(622, vec![3, 1], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(622, vec![4, 1], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(622, vec![5, 1], 1, false)], ctrl: Ctrl::Return(11, vec![8]) }))) }))) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(12, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(622, vec![5, 1], 1, false)], ctrl: Ctrl::Return(13, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 14, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_623() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(622, vec![3, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(623, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_624() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 2]), Op::Const(G::from_u64(1)), Op::Sub(1, 9), Op::Call(624, vec![5, 10, 8], 2, false)], ctrl: Ctrl::Return(1, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 2]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_625() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 12), Op::Sub(13, 3), Op::AssertEq(vec![9], vec![14], Some("recursive occurrence: parameter arg is not the parameter binder".into())), Op::Add(3, 12), Op::Call(625, vec![7, 1, 2, 15], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_626() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(609, vec![1, 7, 18], 0, false), Op::Call(790, vec![2], 1, false), Op::Add(9, 10), Op::AssertEq(vec![19], vec![20], Some("recursive occurrence is not fully applied".into())), Op::Call(625, vec![2, 9, 4, 18], 0, false), Op::Call(801, vec![2, 9], 1, false), Op::Call(623, vec![21, 3], 1, false), Op::AssertEq(vec![22], vec![18], Some("recursive occurrence: index argument mentions the block".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 17, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_627() -> Function { + Function { body: Block { ops: vec![Op::Call(622, vec![0, 1], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![0, 2], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(622, vec![7, 1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![10], vec![11], Some("strict positivity: block occurs left of an arrow".into())), Op::Store(vec![11, 7, 2]), Op::Call(627, vec![8, 1, 12, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(125, vec![5], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::Call(621, vec![13, 1], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(790, vec![2], 1, false), Op::Call(626, vec![13, 14, 11, 1, 17], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![13], 1, false), Op::Load(12, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(5), Block { ops: vec![Op::Call(801, vec![11, 21], 1, false), Op::Call(623, vec![30, 1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![31], vec![32], Some("strict positivity: block occurs in a nested inductive's index args".into())), Op::Store(vec![32, 25, 1]), Op::Call(800, vec![11, 21], 1, false), Op::Call(788, vec![34], 1, false), Op::Call(628, vec![25, 26, 23, 33, 32, 21, 35], 0, false)], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 35, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_628() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 4)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![0, 1, 4], 1, false), Op::Load(12, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(624, vec![11, 5, 22], 2, false), Op::Const(G::from_u64(0)), Op::Call(382, vec![23, 6, 25], 1, false), Op::Call(629, vec![26, 3, 22, 25], 0, false), Op::Add(4, 21), Op::Call(628, vec![0, 1, 2, 3, 27, 5, 6], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 19, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_629() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Call(627, vec![5, 1, 2, 3], 0, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 2]), Op::Call(629, vec![6, 1, 9, 3], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_630() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 2, 6]), Op::Call(624, vec![0, 1, 3], 2, false), Op::Call(629, vec![8, 7, 9, 5], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_631() -> Function { + Function { body: Block { ops: vec![Op::Add(1, 2), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(615, vec![0, 8, 10], 1, false), Op::Const(G::from_u64(0)), Op::Call(632, vec![0, 1, 2, 3, 4, 5, 6, 11, 7, 12], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 3, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_632() -> Function { + Function { body: Block { ops: vec![Op::Sub(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![5, 6, 9], 1, false), Op::Load(12, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(6), Block { ops: vec![Op::Call(2, vec![15, 5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![24], vec![25], Some("ctor belongs to a different block than its inductive".into())), Op::AssertEq(vec![16], vec![6], Some("ctor points at a different member of the block".into())), Op::AssertEq(vec![17], vec![9], Some("ctor's stored index differs from its position".into())), Op::AssertEq(vec![18], vec![1], Some("ctor parameter count differs from the inductive's".into())), Op::Call(614, vec![0, 14, 1], 0, false), Op::Call(612, vec![14, 18, 2, 19, 4, 5, 6], 0, false), Op::Call(618, vec![14, 18, 7], 0, false)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26]), Op::Call(630, vec![14, 18, 5, 27], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(9, 26), Op::Call(632, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 27], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 10, selectors: 4, auxiliaries: 17, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_633() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Call(631, vec![2, 3, 4, 5, 1, 7, 8, 6], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_634() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![7, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(293, vec![7], 48, false)], ctrl: Ctrl::Match(14, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(635, vec![15, 2, 3, 4, 8, 62, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 4, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_635() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Sub(5, 4), Op::EqZero(54)], ctrl: Ctrl::Match(55, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 56), Op::Call(635, vec![53, 1, 2, 3, 4, 57, 6], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(300, vec![6, 5], 1, false), Op::Load(12, 56)], ctrl: Ctrl::Match(57, [(G::from_u64(5), Block { ops: vec![Op::AssertEq(vec![60], vec![2], Some("mutual block peers disagree on parameter count".into())), Op::Call(614, vec![1, 59, 2], 0, false), Op::Add(2, 3), Op::Const(G::from_u64(1)), Op::Store(vec![70, 70, 70]), Op::Call(615, vec![1, 69, 71], 1, false), Op::Add(60, 61), Op::Call(615, vec![59, 73, 71], 1, false), Op::Call(335, vec![72, 74], 1, false), Op::AssertEq(vec![75], vec![70], Some("mutual block peers land in different universes".into())), Op::Add(5, 70), Op::Call(635, vec![53, 1, 2, 3, 4, 76, 6], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 69), Op::Call(635, vec![53, 1, 2, 3, 4, 70, 6], 0, false)], ctrl: Ctrl::Return(3, vec![]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 54), Op::Call(635, vec![53, 1, 2, 3, 4, 55, 6], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 5, auxiliaries: 68, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_636() -> Function { + Function { body: Block { ops: vec![Op::Call(308, vec![0], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![17]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17]), Op::Call(637, vec![5, 9, 10, 18], 1, false)], ctrl: Ctrl::Return(5, vec![19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![17]) }))) }))) }))) }, layout: FunctionLayout { input_size: 16, selectors: 8, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_637() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Call(638, vec![0, 2, 4, 3, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 5, 3]), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(637, vec![6, 11, 2, 9], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_638() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(125, vec![0], 2, false), Op::Call(639, vec![4, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(520, vec![7, 3], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12]), Op::Call(335, vec![10, 13], 1, false), Op::Sub(11, 14), Op::Sub(1, 11), Op::Sub(16, 2)], ctrl: Ctrl::MatchContinue(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 17, 4])], ctrl: Ctrl::Yield(2, vec![19]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 7, 3]), Op::Const(G::from_u64(1)), Op::Add(2, 21), Op::Call(638, vec![8, 1, 22, 20, 18], 1, false)], ctrl: Ctrl::Return(3, vec![23]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_639() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(640, vec![1, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(639, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_640() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Sub(6, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(640, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(640, vec![4, 1], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_641() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Call(642, vec![7, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(3, 4), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(615, vec![2, 14, 16], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18]), Op::Call(335, vec![17, 19], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(301, vec![7, 8, 21], 1, false), Op::Load(12, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(6), Block { ops: vec![Op::EqZero(30)], ctrl: Ctrl::Return(2, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![35]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![21]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![13]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 6, auxiliaries: 23, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_642() -> Function { + Function { body: Block { ops: vec![Op::Call(2, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(644, vec![4, 51], 1, false)], ctrl: Ctrl::Return(1, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![51]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_643() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![49]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![49]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 50, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_644() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![49]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![49]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 49), Op::Call(644, vec![48, 50], 1, false)], ctrl: Ctrl::Return(2, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(644, vec![48, 1], 1, false)], ctrl: Ctrl::Return(3, vec![49]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 50, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_645() -> Function { + Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(2, 5), Op::Add(1, 6), Op::Call(608, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Call(125, vec![10], 2, false), Op::Load(4, 13)], ctrl: Ctrl::Match(15, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_646() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Add(3, 5), Op::Add(12, 6), Op::Add(13, 4), Op::Call(608, vec![2, 14], 1, false), Op::Load(4, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Call(125, vec![17], 2, false), Op::Load(4, 20)], ctrl: Ctrl::Match(22, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26])], ctrl: Ctrl::Return(1, vec![27]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20])], ctrl: Ctrl::Return(2, vec![21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(3, vec![13]) }))) }, layout: FunctionLayout { input_size: 12, selectors: 4, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_647() -> Function { + Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(2, 6), Op::Add(1, 7), Op::Call(608, vec![0, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(125, vec![11], 2, false), Op::Call(800, vec![15, 5], 1, false), Op::Add(2, 3), Op::Add(17, 4), Op::Call(648, vec![16, 18], 1, false)], ctrl: Ctrl::Return(0, vec![19]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_648() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(357, vec![3, 5, 1], 1, false), Op::AssertEq(vec![6], vec![5], Some("nested occurrence's parameter references a motive, minor, or index binder".into())), Op::Call(373, vec![3, 1, 5], 1, false), Op::Call(648, vec![4, 1], 1, false), Op::Store(vec![5, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_649() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Add(0, 2), Op::Store(vec![5, 6, 4]), Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(649, vec![0, 1, 9], 1, false), Op::Store(vec![4, 7, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_650() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(651, vec![3, 3, 0, 1, 50], 1, false)], ctrl: Ctrl::Return(0, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 50)], ctrl: Ctrl::Match(51, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(649, vec![1, 52, 63], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![65, 65, 65]), Op::Store(vec![65, 65, 65, 65, 65, 65]), Op::Store(vec![63, 0, 63, 66, 64, 67])], ctrl: Ctrl::Return(1, vec![68]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![63, 63, 63, 63, 63, 63])], ctrl: Ctrl::Return(2, vec![64]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 67, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_651() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![52, 52, 52, 52, 52, 52])], ctrl: Ctrl::Return(0, vec![53]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(305, vec![0, 2, 4], 1, false), Op::Call(300, vec![2, 4], 1, false), Op::Load(12, 53)], ctrl: Ctrl::MatchContinue(54, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![55]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![66]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(649, vec![3, 66, 67], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![69, 69, 69]), Op::Add(4, 69), Op::Call(651, vec![0, 51, 2, 3, 71], 1, false), Op::Store(vec![67, 52, 67, 70, 68, 72])], ctrl: Ctrl::Return(3, vec![73]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 52), Op::Call(651, vec![0, 51, 2, 3, 53], 1, false)], ctrl: Ctrl::Return(4, vec![54]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 68, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_652() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(2, vec![4, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(655, vec![6, 2], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(652, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(652, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(652, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_653() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Sub(4, 8)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![11]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(338, vec![4, 8], 1, false)], ctrl: Ctrl::Return(4, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![11]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(654, vec![5, 9], 1, false)], ctrl: Ctrl::Return(6, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![11]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(3), Block { ops: vec![Op::Call(653, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(653, vec![5, 9], 1, false)], ctrl: Ctrl::Return(9, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(11, vec![11]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(4), Block { ops: vec![Op::Call(653, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(653, vec![5, 9], 1, false)], ctrl: Ctrl::Return(12, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(14, vec![11]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(653, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(653, vec![5, 9], 1, false)], ctrl: Ctrl::Return(15, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(17, vec![11]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(6), Block { ops: vec![Op::Call(653, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(653, vec![5, 9], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(653, vec![6, 10], 1, false)], ctrl: Ctrl::Return(18, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(19, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(20, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(21, vec![11]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![Op::Call(351, vec![4, 5, 8, 9], 1, false)], ctrl: Ctrl::Return(22, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![11]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Sub(5, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(653, vec![6, 10], 1, false)], ctrl: Ctrl::Return(24, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(25, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(26, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(27, vec![11]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 28, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_654() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(338, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(654, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_655() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(653, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(655, vec![4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![9]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_656() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Call(647, vec![2, 3, 5, 6, 4, 12], 1, false)], ctrl: Ctrl::Return(0, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_657() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(658, vec![3, 3, 0, 50, 1], 1, false)], ctrl: Ctrl::Return(0, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_658() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(305, vec![0, 2, 3], 1, false), Op::Call(298, vec![52], 1, false), Op::Load(12, 53)], ctrl: Ctrl::Match(54, [(G::from_u64(7), Block { ops: vec![Op::Call(645, vec![56, 57, 59, 60, 58], 1, false), Op::Call(298, vec![66], 1, false), Op::Load(12, 67)], ctrl: Ctrl::Match(68, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![75]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![4]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![4]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 52), Op::Call(658, vec![0, 51, 2, 53, 4], 1, false)], ctrl: Ctrl::Return(4, vec![54]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 77, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_659() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::MatchContinue(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(658, vec![4, 4, 0, 51, 1], 1, false)], ctrl: Ctrl::Yield(0, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![1]) }))) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Call(293, vec![51], 48, false)], ctrl: Ctrl::MatchContinue(52, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(52, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(651, vec![53, 53, 51, 2, 100], 1, false)], ctrl: Ctrl::Yield(2, vec![101]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(298, vec![51], 1, false), Op::Load(12, 100)], ctrl: Ctrl::Match(101, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(649, vec![2, 102, 113], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![115, 115, 115]), Op::Store(vec![115, 115, 115, 115, 115, 115]), Op::Store(vec![113, 51, 113, 116, 114, 117])], ctrl: Ctrl::Yield(3, vec![118]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![113, 113, 113, 113, 113, 113])], ctrl: Ctrl::Yield(4, vec![114]) }))) }))) })), 1, 18, 6, Box::new(Block { ops: vec![Op::Call(643, vec![0], 1, false)], ctrl: Ctrl::Match(101, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![100]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(660, vec![0, 51, 2, 100], 1, false)], ctrl: Ctrl::Return(6, vec![102]) }))) })) })) }, layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 121, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_660() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(661, vec![5, 5, 0, 1, 2, 3, 52], 1, false)], ctrl: Ctrl::Return(0, vec![53]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 50, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_661() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(305, vec![0, 2, 6], 1, false), Op::Call(298, vec![54], 1, false), Op::Load(12, 55)], ctrl: Ctrl::MatchContinue(56, [(G::from_u64(7), Block { ops: vec![Op::Call(645, vec![58, 59, 61, 62, 60], 1, false), Op::Call(298, vec![68], 1, false), Op::Load(12, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![77, 3], 1, false)], ctrl: Ctrl::Match(82, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(1, vec![83, 68, 83, 73, 71]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(2, vec![83, 68, 83, 73, 71]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(3, vec![82, 68, 82, 82, 82]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(4, vec![68, 3, 68, 68, 68]) })), 5, 16, 4, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(68, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 73), Op::Call(661, vec![0, 53, 2, 3, 4, 5, 74], 1, false)], ctrl: Ctrl::Return(5, vec![75]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(656, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 71], 1, false), Op::Call(646, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67], 1, false), Op::Call(652, vec![5, 69, 73], 1, false)], ctrl: Ctrl::Match(75, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 76), Op::Call(661, vec![0, 53, 2, 3, 4, 5, 77], 1, false)], ctrl: Ctrl::Return(6, vec![78]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(799, vec![5, 69, 76, 73, 74], 1, false), Op::Add(6, 76), Op::Call(661, vec![0, 53, 2, 3, 4, 77, 78], 1, false)], ctrl: Ctrl::Return(7, vec![79]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 54), Op::Call(661, vec![0, 53, 2, 3, 4, 5, 55], 1, false)], ctrl: Ctrl::Return(8, vec![56]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 90, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_662() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 9]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![4, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 10), Op::Call(662, vec![8, 1, 11], 2, false)], ctrl: Ctrl::Return(2, vec![12, 13]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_663() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![6, 1], 1, false), Op::Sub(2, 7)], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![13]) })), 1, 1, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Call(655, vec![8, 3], 1, false)], ctrl: Ctrl::Yield(3, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(4, vec![14]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Mul(11, 13), Op::Mul(15, 14)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![17, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 17), Op::Call(663, vec![10, 1, 2, 3, 18], 2, false)], ctrl: Ctrl::Return(6, vec![19, 20]) }))) })) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 17, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_664() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![9, 8, 11, 11]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(664, vec![7, 9], 4, false)], ctrl: Ctrl::Return(2, vec![10, 11, 12, 13]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_665() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Sub(6, 0), Op::Store(vec![4, 7, 4, 4])], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![3], 1, false), Op::U32LessThan(0, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(792, vec![3, 0], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Sub(8, 0), Op::Store(vec![6, 9, 6, 6])], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 11, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_666() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(665, vec![5, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(378, vec![8, 10, 11], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Add(5, 13), Op::Call(666, vec![12, 14, 2, 3, 4, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_667() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(667, vec![4, 8], 1, false), Op::Store(vec![6, 3, 9])], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(428, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 14), Op::Call(667, vec![11, 15], 1, false), Op::Store(vec![13, 10, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(3, vec![14]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_668() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Sub(7, 3), Op::Add(8, 2), Op::Store(vec![5, 9, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![11, 0, 10, 5]), Op::Add(3, 6), Op::Call(668, vec![12, 1, 2, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_669() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(369, vec![4, 2, 6], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![8, 0, 7, 6]), Op::Call(669, vec![9, 5, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_670() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(668, vec![0, 1, 2, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(669, vec![0, 4, 2], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_671() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Sub(6, 2), Op::Store(vec![4, 7, 4, 4]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 0, 8, 4]), Op::Add(2, 5), Op::Call(671, vec![10, 1, 11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_672() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(672, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_673() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(673, vec![4, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 3, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(428, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Call(673, vec![11, 14], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![17, 10, 15])], ctrl: Ctrl::Return(2, vec![18, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(3, vec![14, 0]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_674() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(369, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(674, vec![5, 1, 9], 1, false), Op::Store(vec![6, 7, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_675() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(669, vec![0, 5, 3], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(679, vec![0, 1, 2, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_676() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(1, 2), Op::Store(vec![4, 5, 4, 4]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 0, 6, 4]), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(676, vec![8, 1, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_677() -> Function { + Function { body: Block { ops: vec![Op::Call(347, vec![1, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(666, vec![9, 2, 6, 7, 8, 10], 1, false), Op::Call(667, vec![11, 3], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![13, 0, 4, 10])], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(668, vec![14, 6, 3, 15], 1, false)], ctrl: Ctrl::Yield(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(669, vec![14, 8, 3], 1, false)], ctrl: Ctrl::Yield(1, vec![15]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(671, vec![15, 3, 16], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![18, 5, 16, 16]), Op::Const(G::from_u64(5)), Op::Store(vec![20, 17, 19, 16]), Op::Call(672, vec![21, 12], 1, false)], ctrl: Ctrl::Return(2, vec![22]) })) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 12, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_678() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(713, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_679() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(2, 3), Op::Store(vec![5, 6, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![8, 0, 7, 5]), Op::Const(G::from_u64(1)), Op::Add(3, 10), Op::Call(679, vec![9, 1, 2, 11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_680() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(680, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_681() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(664, vec![6, 9], 4, false), Op::Call(298, vec![10], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(682, vec![17, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(682, vec![0, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(1, vec![27]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 20, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_682() -> Function { + Function { body: Block { ops: vec![Op::Call(805, vec![8], 1, false), Op::Const(G::from_u64(0)), Op::Call(649, vec![7, 1, 12], 1, false), Op::Call(347, vec![0, 13], 1, false), Op::Call(673, vec![14, 4], 2, false), Op::Call(678, vec![8, 6, 4], 1, false), Op::Call(696, vec![8, 9, 4, 11, 4], 1, false), Op::Call(790, vec![18], 1, false), Op::Call(664, vec![8, 10], 4, false), Op::Call(298, vec![20], 1, false), Op::Load(12, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(5), Block { ops: vec![Op::Call(347, vec![27, 23], 1, false), Op::Const(G::from_u64(0)), Op::Call(666, vec![37, 28, 4, 21, 22, 38], 1, false), Op::Call(667, vec![39, 5], 1, false), Op::Add(11, 19), Op::Call(674, vec![40, 41, 38], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![43, 20, 23, 38]), Op::Add(4, 11), Op::Add(45, 19), Op::Add(46, 5), Op::Const(G::from_u64(1)), Op::Sub(47, 48), Op::Add(41, 5)], ctrl: Ctrl::MatchContinue(21, [(G::from_u64(1), Block { ops: vec![Op::Call(669, vec![44, 22, 50], 1, false)], ctrl: Ctrl::Yield(0, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(679, vec![44, 4, 49, 51], 1, false)], ctrl: Ctrl::Yield(1, vec![52]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(671, vec![51, 5, 52], 1, false), Op::Const(G::from_u64(1)), Op::Add(47, 54), Op::Sub(55, 54), Op::Add(4, 10), Op::Sub(56, 57), Op::Store(vec![52, 58, 52, 52]), Op::Call(676, vec![59, 5, 52], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![52, 52, 52, 52]), Op::Store(vec![61, 60, 62, 52]), Op::Const(G::from_u64(5)), Op::Store(vec![64, 53, 63, 52]), Op::Call(672, vec![65, 42], 1, false), Op::Call(672, vec![66, 18], 1, false), Op::Call(672, vec![67, 17], 1, false), Op::Call(672, vec![68, 15], 1, false)], ctrl: Ctrl::Return(2, vec![69]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 11, selectors: 3, auxiliaries: 44, lookups: 27 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_683() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(301, vec![20, 21, 26], 1, false), Op::Load(12, 27), Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![40, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26]), Op::Store(vec![27, 28, 26, 26])], ctrl: Ctrl::Yield(1, vec![26, 26, 26, 29, 26, 26, 26, 26, 26, 26, 26, 26, 26]) })), 13, 13, 2, Box::new(Block { ops: vec![Op::Add(16, 17), Op::Const(G::from_u64(1)), Op::Store(vec![40, 40, 40]), Op::Call(615, vec![15, 39, 41], 1, false), Op::Call(642, vec![20, 25], 1, false), Op::Call(636, vec![42, 18, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 43], 1, false)], ctrl: Ctrl::MatchContinue(44, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![45, 46, 46])], ctrl: Ctrl::Yield(2, vec![47]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45])], ctrl: Ctrl::Yield(3, vec![46]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(716, vec![1, 46], 1, false), Op::Call(659, vec![10, 20, 44], 1, false), Op::Call(690, vec![48, 10, 12], 1, false), Op::Call(693, vec![48], 1, false), Op::Call(643, vec![10], 1, false), Op::Call(643, vec![20], 1, false), Op::Const(G::from_u64(1)), Op::Call(2, vec![10, 20], 1, false), Op::Sub(53, 54), Op::Mul(52, 55), Op::Mul(51, 56)], ctrl: Ctrl::MatchContinue(57, [(G::from_u64(1), Block { ops: vec![Op::Call(656, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16], 1, false)], ctrl: Ctrl::Yield(4, vec![58]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![58, 58, 58])], ctrl: Ctrl::Yield(5, vec![59]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(663, vec![48, 25, 57, 58, 59], 2, false)], ctrl: Ctrl::Match(60, [(G::from_u64(1), Block { ops: vec![Op::Call(684, vec![48, 61, 18, 20, 21, 3, 5, 6, 47, 49, 50, 7, 2, 15, 14, 17, 45, 44], 0, false)], ctrl: Ctrl::Return(6, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(662, vec![48, 25, 62], 2, false)], ctrl: Ctrl::Match(63, [(G::from_u64(1), Block { ops: vec![Op::Call(684, vec![48, 64, 18, 20, 21, 3, 5, 6, 47, 49, 50, 7, 2, 15, 14, 17, 45, 44], 0, false)], ctrl: Ctrl::Return(7, vec![]) })].into_iter().collect(), None) }))) })) })) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 26, selectors: 9, auxiliaries: 51, lookups: 19 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_684() -> Function { + Function { body: Block { ops: vec![Op::Call(664, vec![0, 1], 4, false), Op::Call(681, vec![13, 14, 5, 15, 16, 17, 0, 10, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23]), Op::Call(449, vec![12, 22, 24], 1, false), Op::AssertEq(vec![25], vec![23], Some("recursor's declared type is not def-eq to the canonical reconstruction".into())), Op::Call(805, vec![0], 1, false), Op::Call(696, vec![0, 10, 5, 26, 5], 1, false), Op::Call(790, vec![27], 1, false), Op::AssertEq(vec![6], vec![26], Some("recursor motive count disagrees with the canonical reconstruction".into())), Op::AssertEq(vec![7], vec![28], Some("recursor minor count disagrees with the canonical reconstruction".into())), Op::Const(G::from_u64(0)), Op::Call(685, vec![0, 1, 29], 1, false), Op::Call(686, vec![2, 30, 3, 4, 5, 6, 7, 21, 8, 0, 9, 10, 19, 20, 29], 1, false), Op::Call(687, vec![11, 31, 5, 6, 7, 3, 4, 2, 29], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 18, selectors: 1, auxiliaries: 13, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_685() -> Function { + Function { body: Block { ops: vec![Op::Sub(2, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(298, vec![5], 1, false), Op::Load(12, 10)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(3, vec![23]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 24), Op::Call(685, vec![9, 1, 25], 1, false), Op::Add(23, 26)], ctrl: Ctrl::Return(4, vec![27]) })) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 24, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_686() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16])], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![2, 3, 14], 1, false), Op::Load(12, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(6), Block { ops: vec![Op::Add(1, 14), Op::Call(689, vec![19, 29, 4, 5, 6, 23, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(14, 32), Op::Call(686, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 33], 1, false), Op::Store(vec![31, 30, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29])], ctrl: Ctrl::Return(2, vec![30]) }))) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 18, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_687() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![10], vec![8], Some("recursor rule is out of ctor order".into())), Op::U32LessThan(10, 7), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], Some("recursor rule names a ctor index out of range".into())), Op::Call(301, vec![5, 6, 10], 1, false), Op::Load(12, 16)], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(6), Block { ops: vec![Op::AssertEq(vec![11], vec![24], Some("recursor rule field count differs from the ctor's".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), None, 0, 0, 0, Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Add(2, 3), Op::Add(32, 4), Op::Add(33, 11), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Call(718, vec![12, 34, 35, 37], 3, false), Op::AssertEq(vec![39], vec![34], Some("recursor rule rhs has too few binders to peel".into())), Op::Call(449, vec![38, 30, 37], 1, false), Op::AssertEq(vec![41], vec![36], Some("recursor rule rhs differs from canonical reconstruction".into())), Op::Add(8, 36), Op::Call(687, vec![13, 31, 2, 3, 4, 5, 6, 7, 42], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 33, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_688() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(782, vec![2, 11, 15], 1, false), Op::Store(vec![15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15]), Op::Call(782, vec![4, 16, 17], 1, false), Op::Call(782, vec![5, 16, 15], 1, false), Op::Add(6, 7), Op::Add(20, 8), Op::Add(21, 9), Op::Call(792, vec![3, 13], 1, false), Op::Sub(9, 13), Op::Call(369, vec![23, 24, 15], 1, false), Op::Add(7, 8), Op::Call(369, vec![25, 26, 9], 1, false), Op::Call(702, vec![27], 2, false), Op::Call(790, vec![28], 1, false), Op::Add(22, 30), Op::Const(G::from_u64(2)), Op::Store(vec![32, 18, 10, 15]), Op::Const(G::from_u64(1)), Op::Sub(31, 34), Op::Call(679, vec![33, 6, 35, 15], 1, false), Op::Sub(35, 6), Op::Call(679, vec![36, 7, 37, 15], 1, false), Op::Sub(37, 7), Op::Call(679, vec![38, 8, 39, 15], 1, false), Op::Store(vec![34, 34, 34]), Op::Call(428, vec![29, 41], 1, false), Op::Call(125, vec![42], 2, false), Op::Call(801, vec![44, 19], 1, false), Op::Call(266, vec![40, 45], 1, false), Op::Sub(9, 34), Op::Sub(47, 13), Op::Add(48, 30), Op::Store(vec![15, 49, 15, 15]), Op::Call(671, vec![50, 30, 15], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![52, 46, 51, 15]), Op::Call(680, vec![53, 28], 1, false), Op::Store(vec![52, 0, 54, 15]), Op::Add(11, 34), Op::Call(688, vec![55, 14, 2, 3, 4, 5, 6, 7, 8, 9, 10, 56], 1, false)], ctrl: Ctrl::Return(1, vec![57]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 2, auxiliaries: 30, lookups: 26 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_689() -> Function { + Function { body: Block { ops: vec![Op::Call(347, vec![0, 6], 1, false), Op::Call(608, vec![13, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(699, vec![14, 15], 1, false), Op::Add(2, 3), Op::Add(17, 4), Op::Add(18, 16), Op::Call(700, vec![13, 5, 5, 15, 11, 12, 15], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(712, vec![20, 8, 22, 22, 22, 15, 15], 4, false), Op::Sub(19, 21), Op::Add(17, 1), Op::Sub(27, 28), Op::Store(vec![15, 29, 15, 15]), Op::Call(706, vec![30, 16, 16, 15], 1, false), Op::Call(688, vec![31, 24, 25, 23, 9, 10, 2, 3, 4, 16, 7, 15], 1, false)], ctrl: Ctrl::Return(0, vec![32]) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_690() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(691, vec![1, 4, 6, 5, 2], 1, false), Op::Const(G::from_u64(0)), Op::Call(690, vec![8, 1, 2], 1, false), Op::Store(vec![10, 9, 11])], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_691() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(692, vec![6, 6, 0, 1, 2, 3, 4, 53], 1, false)], ctrl: Ctrl::Return(0, vec![54]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![4]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 50, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_692() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::Call(305, vec![0, 2, 7], 1, false), Op::Call(298, vec![55], 1, false), Op::Load(12, 56)], ctrl: Ctrl::MatchContinue(57, [(G::from_u64(7), Block { ops: vec![Op::Call(645, vec![59, 60, 62, 63, 61], 1, false), Op::Call(298, vec![69], 1, false), Op::Load(12, 70)], ctrl: Ctrl::MatchContinue(71, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![74]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![83]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Call(2, vec![69, 3], 1, false)], ctrl: Ctrl::Match(84, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(3, vec![85]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(647, vec![59, 60, 62, 63, 61, 83], 1, false), Op::Call(655, vec![85, 4], 1, false)], ctrl: Ctrl::Yield(4, vec![86]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(5, vec![85]) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(6, vec![69]) })), 1, 20, 6, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(69, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(7, vec![55]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 70), Op::Call(692, vec![0, 54, 2, 3, 4, 5, 6, 71], 1, false)], ctrl: Ctrl::Return(8, vec![72]) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 55), Op::Call(692, vec![0, 54, 2, 3, 4, 5, 6, 56], 1, false)], ctrl: Ctrl::Return(9, vec![57]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 10, auxiliaries: 85, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_693() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(298, vec![2], 1, false), Op::Load(12, 7)], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![20]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(693, vec![6], 1, false), Op::Store(vec![21, 20, 22])], ctrl: Ctrl::Return(3, vec![23]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 24, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_694() -> Function { + Function { body: Block { ops: vec![Op::Call(304, vec![0], 8, false), Op::Call(304, vec![1], 8, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(79, vec![19, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 22, 22, 22, 22], 1, false), Op::Call(23, vec![23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_695() -> Function { + Function { body: Block { ops: vec![Op::Sub(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16])], ctrl: Ctrl::Return(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(301, vec![10, 11, 14], 1, false), Op::Load(12, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(6), Block { ops: vec![Op::Call(694, vec![11, 14, 10], 1, false), Op::Call(701, vec![29, 19, 23, 1, 2, 3, 4, 5, 6, 7, 13, 8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(13, 32), Op::Add(14, 32), Op::Call(695, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 33, 34], 1, false), Op::Store(vec![31, 30, 35])], ctrl: Ctrl::Return(1, vec![36]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 19, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_696() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(697, vec![0, 0, 1, 2, 3, 4, 5, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_697() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Return(0, vec![15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(298, vec![9], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(695, vec![9, 10, 11, 12, 1, 2, 3, 4, 5, 7, 22, 23, 20, 6, 27], 1, false), Op::Call(790, vec![28], 1, false), Op::Add(6, 29), Op::Const(G::from_u64(1)), Op::Add(7, 31), Op::Call(697, vec![13, 1, 2, 3, 4, 5, 30, 32], 1, false), Op::Call(789, vec![28, 33], 1, false)], ctrl: Ctrl::Return(1, vec![34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(7, 27), Op::Call(697, vec![13, 1, 2, 3, 4, 5, 6, 28], 1, false)], ctrl: Ctrl::Return(2, vec![29]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_698() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Sub(7, 0), Op::Store(vec![5, 8, 5, 5])], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(790, vec![4], 1, false), Op::U32LessThan(0, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(792, vec![4, 0], 1, false), Op::Const(G::from_u64(0)), Op::Call(369, vec![7, 2, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Sub(9, 0), Op::Store(vec![7, 10, 7, 7])], ctrl: Ctrl::Return(2, vec![11]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 11, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_699() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(699, vec![4, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_700() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(698, vec![6, 2, 3, 4, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(378, vec![9, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 14), Op::Add(6, 14), Op::Call(700, vec![13, 15, 2, 3, 4, 5, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Call(428, vec![0, 12], 1, false), Op::Load(4, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Call(698, vec![6, 2, 3, 4, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(378, vec![16, 18, 19], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 21), Op::Add(6, 21), Op::Call(700, vec![20, 22, 2, 3, 4, 5, 23], 1, false)], ctrl: Ctrl::Return(2, vec![24]) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 16, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_701() -> Function { + Function { body: Block { ops: vec![Op::Call(347, vec![1, 5], 1, false), Op::Add(9, 10), Op::Add(8, 14), Op::Const(G::from_u64(0)), Op::Call(700, vec![13, 2, 15, 14, 3, 4, 16], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![18, 18, 18]), Op::Call(712, vec![17, 6, 19, 19, 19, 16, 14], 4, false), Op::Call(790, vec![20], 1, false), Op::Call(790, vec![21], 1, false), Op::Add(24, 25), Op::Add(15, 26), Op::Call(125, vec![23], 2, false), Op::Call(801, vec![29, 2], 1, false), Op::Call(705, vec![30, 25, 16], 1, false), Op::Sub(27, 18), Op::Add(11, 12), Op::Sub(32, 33), Op::Store(vec![16, 34, 16, 16]), Op::Call(266, vec![35, 31], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![37, 0, 5, 16]), Op::Call(707, vec![38, 2, 8, 27, 3, 4], 1, false), Op::Call(706, vec![39, 24, 26, 16], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![41, 36, 40, 16]), Op::Call(704, vec![21, 22, 20, 7, 11, 24, 15, 16], 1, false), Op::Call(672, vec![42, 43], 1, false), Op::Call(672, vec![44, 20], 1, false)], ctrl: Ctrl::Return(0, vec![45]) }, layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 23, lookups: 19 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_702() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(703, vec![0, 2], 2, false), Op::Call(788, vec![3], 1, false)], ctrl: Ctrl::Return(0, vec![5, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_703() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 3, 1]), Op::Call(703, vec![4, 7], 2, false)], ctrl: Ctrl::Return(0, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1, 0]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_704() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11])], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(782, vec![1, 7, 11], 1, false), Op::Call(782, vec![3, 12, 11], 1, false), Op::Add(5, 7), Op::Add(6, 14), Op::Call(792, vec![2, 9], 1, false), Op::Sub(5, 9), Op::Add(17, 7), Op::Call(369, vec![16, 18, 11], 1, false), Op::Call(702, vec![19], 2, false), Op::Call(790, vec![20], 1, false), Op::Add(15, 22), Op::Const(G::from_u64(1)), Op::Sub(23, 24), Op::Add(4, 12), Op::Sub(25, 26), Op::Add(6, 9), Op::Sub(25, 28), Op::Store(vec![24, 24, 24]), Op::Call(428, vec![21, 30], 1, false), Op::Call(125, vec![31], 2, false), Op::Call(801, vec![33, 13], 1, false), Op::Store(vec![11, 27, 11, 11]), Op::Call(266, vec![35, 34], 1, false), Op::Store(vec![11, 29, 11, 11]), Op::Call(671, vec![37, 22, 11], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![39, 36, 38, 11]), Op::Call(672, vec![40, 20], 1, false), Op::Add(7, 24), Op::Call(704, vec![10, 1, 2, 3, 4, 5, 6, 42], 1, false), Op::Store(vec![11, 41, 43])], ctrl: Ctrl::Return(1, vec![44]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 24, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_705() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(369, vec![4, 1, 2], 1, false), Op::Call(705, vec![5, 1, 2], 1, false), Op::Store(vec![6, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_706() -> Function { + Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 6), Op::Sub(7, 3), Op::Store(vec![5, 8, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![10, 0, 9, 5]), Op::Add(3, 6), Op::Call(706, vec![11, 1, 2, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_707() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 6), Op::Const(G::from_u64(0)), Op::Call(679, vec![0, 2, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 2), Op::Call(669, vec![0, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_708() -> Function { + Function { body: Block { ops: vec![Op::Call(709, vec![0, 1, 2], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_709() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(428, vec![0, 4], 1, false), Op::Load(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(5), Block { ops: vec![Op::Call(709, vec![8, 1, 2], 2, false)], ctrl: Ctrl::Return(0, vec![10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(125, vec![5], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(710, vec![1, 13, 11, 2, 16], 2, false)], ctrl: Ctrl::Return(1, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![16, 16]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_710() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, vec![6, 1], 1, false)], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(711, vec![8, 2, 3], 1, false)], ctrl: Ctrl::Yield(2, vec![12]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Mul(11, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![14, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 14), Op::Call(710, vec![10, 1, 2, 3, 15], 2, false)], ctrl: Ctrl::Return(4, vec![16, 17]) }))) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_711() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(369, vec![4, 2, 9], 1, false), Op::Call(653, vec![10, 7], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(711, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![12]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_712() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Add(6, 5), Op::Call(708, vec![8, 1, 11], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 8, 2])], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 5, 3]), Op::Store(vec![16, 13, 4]), Op::Const(G::from_u64(1)), Op::Add(5, 19), Op::Call(712, vec![9, 1, 15, 17, 18, 20, 6], 4, false)], ctrl: Ctrl::Return(0, vec![21, 22, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 16), Op::Call(712, vec![9, 1, 15, 3, 4, 17, 6], 4, false)], ctrl: Ctrl::Return(1, vec![18, 19, 20, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(788, vec![2], 1, false), Op::Call(788, vec![3], 1, false), Op::Call(788, vec![4], 1, false)], ctrl: Ctrl::Return(2, vec![11, 12, 13, 0]) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_713() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(298, vec![5], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(5), Block { ops: vec![Op::Call(677, vec![5, 13, 14, 15, 8, 1, 2, 6, 7], 1, false), Op::Const(G::from_u64(0)), Op::Call(369, vec![23, 3, 24], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 26), Op::Call(713, vec![9, 1, 2, 27], 1, false), Op::Store(vec![24, 25, 28])], ctrl: Ctrl::Return(1, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(713, vec![9, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![23]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_714() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Call(645, vec![2, 3, 5, 6, 4], 1, false), Op::Call(298, vec![13], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(643, vec![10], 1, false), Op::Call(643, vec![22], 1, false), Op::Const(G::from_u64(1)), Op::Call(2, vec![10, 22], 1, false), Op::Sub(29, 30), Op::Mul(28, 31), Op::Mul(27, 32), Op::Call(802, vec![7], 1, false), Op::AssertEq(vec![34], vec![20], Some("recursor rule count differs from the inductive's ctor count".into())), Op::Add(3, 5), Op::Add(6, 4), Op::Add(35, 36), Op::Add(37, 29), Op::Call(608, vec![2, 38], 1, false), Op::Add(5, 6), Op::Add(3, 40), Op::Call(717, vec![7, 41, 1], 0, false)], ctrl: Ctrl::MatchContinue(33, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![3], vec![18], Some("recursor parameter count differs from its inductive's".into())), Op::AssertEq(vec![4], vec![19], Some("recursor index count differs from its inductive's".into())), Op::Add(18, 19), Op::Call(715, vec![2, 3, 5, 6, 4, 42], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(641, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 13], 1, false), Op::AssertEq(vec![8], vec![42], Some("recursor k_flag disagrees with its inductive's K eligibility".into())), Op::Call(633, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], 0, false), Op::Call(683, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 13], 0, false)], ctrl: Ctrl::Return(2, vec![]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 3, auxiliaries: 24, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_715() -> Function { + Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(2, 6), Op::Add(1, 7), Op::Call(608, vec![0, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(125, vec![11], 2, false), Op::Call(790, vec![15], 1, false), Op::AssertEq(vec![16], vec![5], Some("recursor major premise has the wrong number of spine args".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_716() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![4, 1, 3]), Op::Const(G::from_u64(1)), Op::Add(1, 6), Op::Call(716, vec![0, 7], 1, false), Op::Store(vec![3, 5, 8])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_717() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(1, 5), Op::Call(602, vec![6, 8, 2], 0, false), Op::Call(717, vec![7, 1, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_718() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Add(2, 8), Op::Const(G::from_u64(0)), Op::Store(vec![11, 5, 3]), Op::Call(718, vec![6, 9, 10, 12], 3, false)], ctrl: Ctrl::Return(1, vec![13, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 2, 3]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_719() -> Function { + Function { body: Block { ops: vec![Op::Call(597, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Call(602, vec![3, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false), Op::Call(599, vec![13, 3], 0, false), Op::Call(521, vec![3, 2, 16], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Call(602, vec![3, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Store(vec![14, 14, 14]), Op::Call(335, vec![17, 18], 1, false), Op::AssertEq(vec![19], vec![15], Some("theorem's type is not a Prop".into())), Op::Call(599, vec![13, 2], 0, false), Op::Call(599, vec![13, 3], 0, false), Op::Call(521, vec![3, 2, 16], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Call(602, vec![3, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false), Op::Call(599, vec![13, 3], 0, false), Op::Call(521, vec![3, 2, 16], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false), Op::Call(607, vec![12, 3, 1, 2], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false), Op::Call(596, vec![7], 0, false), Op::Call(631, vec![2, 3, 4, 5, 1, 7, 8, 6], 0, false), Op::Call(634, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false), Op::Call(300, vec![3, 4], 1, false), Op::Load(12, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(5), Block { ops: vec![Op::AssertEq(vec![6], vec![22], Some("ctor parameter count differs from its inductive's".into())), Op::Call(614, vec![21, 2, 22], 0, false), Op::Call(612, vec![2, 6, 23, 7, 20, 3, 4], 0, false), Op::Add(22, 23), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Call(615, vec![21, 31, 33], 1, false), Op::Call(618, vec![2, 6, 34], 0, false)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35]), Op::Call(630, vec![2, 6, 3, 36], 0, false)], ctrl: Ctrl::Return(6, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(602, vec![2, 14, 1], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Call(520, vec![2, 16], 1, false), Op::Call(599, vec![13, 2], 0, false), Op::Call(596, vec![10], 0, false), Op::Call(714, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 9, auxiliaries: 20, lookups: 15 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_720() -> Function { + Function { body: Block { ops: vec![Op::Call(298, vec![0], 1, false), Op::Load(12, 1), Op::Call(719, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_721() -> Function { + Function { body: Block { ops: vec![Op::Load(18, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Store(vec![19, 20, 22])], ctrl: Ctrl::Return(0, vec![23]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(721, vec![18], 1, false), Op::Store(vec![19, 20, 21])], ctrl: Ctrl::Return(1, vec![22]) }), (G::from_u64(7), Block { ops: vec![Op::Call(721, vec![2], 1, false), Op::Call(721, vec![3], 1, false), Op::Call(789, vec![19, 20], 1, false)], ctrl: Ctrl::Return(2, vec![21]) }), (G::from_u64(8), Block { ops: vec![Op::Call(721, vec![5], 1, false), Op::Call(721, vec![6], 1, false), Op::Call(789, vec![19, 20], 1, false)], ctrl: Ctrl::Return(3, vec![21]) }), (G::from_u64(9), Block { ops: vec![Op::Call(721, vec![7], 1, false), Op::Call(721, vec![8], 1, false), Op::Call(789, vec![19, 20], 1, false)], ctrl: Ctrl::Return(4, vec![21]) }), (G::from_u64(10), Block { ops: vec![Op::Call(721, vec![7], 1, false), Op::Call(721, vec![8], 1, false), Op::Call(721, vec![9], 1, false), Op::Call(789, vec![20, 21], 1, false), Op::Call(789, vec![19, 22], 1, false)], ctrl: Ctrl::Return(5, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19])], ctrl: Ctrl::Return(6, vec![20]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_722() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(721, vec![2], 1, false), Op::Call(722, vec![3], 1, false), Op::Call(789, vec![4, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_723() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![10], 1, false), Op::Call(723, vec![11], 1, false), Op::Call(789, vec![12, 13], 1, false)], ctrl: Ctrl::Return(1, vec![14]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_724() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![37, 37, 37])], ctrl: Ctrl::Return(0, vec![38]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![35], 1, false), Op::Call(724, vec![36], 1, false), Op::Call(789, vec![37, 38], 1, false)], ctrl: Ctrl::Return(1, vec![39]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 40, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_725() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![48, 48, 48])], ctrl: Ctrl::Return(0, vec![49]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![13], 1, false), Op::Call(721, vec![14], 1, false), Op::Call(789, vec![48, 49], 1, false), Op::Call(725, vec![47], 1, false), Op::Call(789, vec![50, 51], 1, false)], ctrl: Ctrl::Return(1, vec![52]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![28], 1, false), Op::Call(724, vec![29], 1, false), Op::Call(789, vec![48, 49], 1, false), Op::Call(725, vec![47], 1, false), Op::Call(789, vec![50, 51], 1, false)], ctrl: Ctrl::Return(2, vec![52]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![45], 1, false), Op::Call(723, vec![46], 1, false), Op::Call(789, vec![48, 49], 1, false), Op::Call(725, vec![47], 1, false), Op::Call(789, vec![50, 51], 1, false)], ctrl: Ctrl::Return(3, vec![52]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 53, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_726() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(722, vec![45], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![11], 1, false), Op::Call(721, vec![12], 1, false), Op::Call(789, vec![49, 50], 1, false), Op::Call(789, vec![48, 51], 1, false)], ctrl: Ctrl::Return(0, vec![52]) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![43], 1, false), Op::Call(723, vec![44], 1, false), Op::Call(789, vec![49, 50], 1, false), Op::Call(789, vec![48, 51], 1, false)], ctrl: Ctrl::Return(1, vec![52]) }))) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![10], 1, false), Op::Call(789, vec![48, 49], 1, false)], ctrl: Ctrl::Return(2, vec![50]) }))) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(721, vec![10], 1, false), Op::Call(789, vec![48, 49], 1, false)], ctrl: Ctrl::Return(3, vec![50]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(725, vec![1], 1, false), Op::Call(789, vec![48, 49], 1, false)], ctrl: Ctrl::Return(4, vec![50]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![48]) }))) }))) }, layout: FunctionLayout { input_size: 48, selectors: 6, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_727() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(727, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_728() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(730, vec![0, 2, 2, 49], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(728, vec![10], 0, false)], ctrl: Ctrl::Yield(1, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(728, vec![10], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(728, vec![18], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(728, vec![10], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false)], ctrl: Ctrl::Yield(5, vec![]) })), 0, 5, 2, Box::new(Block { ops: vec![Op::Call(726, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48], 1, false), Op::Const(G::from_u64(0)), Op::Call(729, vec![47, 49, 50], 0, false)], ctrl: Ctrl::Return(6, vec![]) })) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 55, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_729() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(727, vec![1, 2], 1, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(1), Block { ops: vec![Op::Call(728, vec![4], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Call(729, vec![5, 1, 8], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_730() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(731, vec![0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 3], 0, false), Op::Const(G::from_u64(1)), Op::Add(3, 51), Op::Call(730, vec![0, 1, 50, 52], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 48, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_731() -> Function { + Function { body: Block { ops: vec![Op::Call(305, vec![1, 0, 47], 1, false), Op::Call(298, vec![48], 1, false), Op::Load(12, 49), Op::Call(719, vec![50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 48], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 48, selectors: 1, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_732() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(53, vec![0, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 3]), Op::Call(23, vec![5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_733() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(53, vec![1, 3], 1, false), Op::Call(53, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 5]), Op::Call(23, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_734() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(99, vec![2], 2, false), Op::Call(732, vec![3], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 3, 8])], ctrl: Ctrl::Return(0, vec![5, 9, 4]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![4, 6, 2]) }), (G::from_u64(2), Block { ops: vec![Op::Call(734, vec![2], 3, false), Op::Call(734, vec![5], 3, false), Op::Call(733, vec![3, 6], 1, false), Op::Call(789, vec![4, 7], 1, false)], ctrl: Ctrl::Return(2, vec![9, 10, 8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_735() -> Function { + Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(1)), Op::IOGetInfo(33, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]), Op::Call(5, vec![33, 34, 35], 1, false), Op::Call(80, vec![36], 2, false), Op::Const(G::from_u64(226)), Op::AssertEq(vec![37], vec![39], Some("assumption tree: wrong TagN header".into())), Op::Call(734, vec![38], 3, false), Op::Load(3, 42), Op::AssertEq(vec![43, 44, 45], vec![33, 33, 33], Some("assumption tree: trailing bytes after tree body".into())), Op::Load(32, 40), Op::AssertEq(vec![46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77], vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], Some("assumption tree: recomputed merkle root != requested root".into()))], ctrl: Ctrl::Return(0, vec![41]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 76, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_736() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(804, vec![8, 10, 1, 2, 3, 4, 5, 6], 6, false), Op::Call(736, vec![9, 11, 12, 13, 14, 15, 16], 6, false)], ctrl: Ctrl::Return(1, vec![17, 18, 19, 20, 21, 22]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_737() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(787, vec![0, 1, 2, 3, 4, 5, 6, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 7, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_738() -> Function { + Function { body: Block { ops: vec![Op::Call(737, vec![0, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(13, [(G::from_u64(1), Block { ops: vec![Op::Call(737, vec![0, 1, 2, 3, 4, 5, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15], vec![16], Some("CheckEnv: walk reached a constant outside the owned set".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(15, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(730, vec![0, 16, 16, 63], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(738, vec![24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(738, vec![24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(5, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(738, vec![32, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(6, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Call(738, vec![24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Yield(7, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false)], ctrl: Ctrl::Yield(8, vec![]) })), 0, 5, 2, Box::new(Block { ops: vec![Op::Call(726, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62], 1, false), Op::Const(G::from_u64(0)), Op::Call(739, vec![61, 63, 64, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Return(9, vec![]) })) }))) })) }))) }, layout: FunctionLayout { input_size: 14, selectors: 10, auxiliaries: 58, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_739() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(727, vec![1, 2], 1, false)], ctrl: Ctrl::MatchContinue(19, [(G::from_u64(1), Block { ops: vec![Op::Call(738, vec![17, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 20), Op::Call(739, vec![18, 1, 21, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 4, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_740() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(738, vec![14, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 16], 0, false), Op::Call(740, vec![15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_741() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Call(735, vec![0], 1, false), Op::Call(742, vec![3], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(735, vec![0], 1, false), Op::Const(G::from_u64(1)), Op::Call(736, vec![3, 4, 4, 4, 4, 4, 4], 6, false), Op::Call(735, vec![2], 1, false), Op::Call(736, vec![11, 4, 4, 4, 4, 4, 4], 6, false), Op::Call(740, vec![3, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_742() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 2), Op::Call(743, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 0, false), Op::Call(742, vec![3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 36, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_743() -> Function { + Function { body: Block { ops: vec![Op::Store(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Call(744, vec![32], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_744() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(730, vec![0, 2, 2, 49], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Load(32, 10), Op::Call(743, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(1, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Load(32, 10), Op::Call(743, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Load(32, 18), Op::Call(743, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false), Op::Load(32, 10), Op::Call(743, vec![49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(720, vec![0], 0, false)], ctrl: Ctrl::Yield(5, vec![]) })), 0, 32, 3, Box::new(Block { ops: vec![Op::Call(726, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48], 1, false), Op::Const(G::from_u64(0)), Op::Call(745, vec![47, 49, 50], 0, false)], ctrl: Ctrl::Return(6, vec![]) })) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 82, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_745() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(727, vec![1, 2], 1, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(1), Block { ops: vec![Op::Load(32, 4), Op::Call(743, vec![7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 32, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Call(745, vec![5, 1, 8], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 37, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_746() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(99, vec![2], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_747() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(84, vec![1], 9, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![11, 2, 3, 4, 5, 6, 7, 8, 9, 10]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_748() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(99, vec![1], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 2, 3]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_749() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(80, vec![1], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 2, 3]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_750() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(80, vec![1], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 4, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4, 5, 3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![4, 5, 3]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_751() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(80, vec![1], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4, 4, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4, 5, 3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![4, 5, 3]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(4, vec![4, 5, 3]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_752() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(119, vec![0], 18, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(752, vec![27, 28, 29, 30, 31, 32, 33, 34, 35], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![38, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 36])], ctrl: Ctrl::Return(1, vec![39, 37]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 32, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_753() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(84, vec![1], 9, false), Op::Call(752, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13, 11, 12]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_754() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::U8BitDecomposition(1), Op::Call(749, vec![10, 9], 3, false), Op::Call(747, vec![11, 20], 10, false), Op::Call(747, vec![12, 30], 10, false), Op::Call(747, vec![13, 40], 10, false), Op::Call(747, vec![14, 50], 10, false), Op::Call(748, vec![15, 60], 3, false)], ctrl: Ctrl::Return(0, vec![18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 64, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_755() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(754, vec![9], 41, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_756() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(755, vec![0], 49, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(756, vec![58, 59, 60, 61, 62, 63, 64, 65, 66], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![69, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 67])], ctrl: Ctrl::Return(1, vec![70, 68]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 63, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_757() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![2, 2, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(84, vec![1], 9, false), Op::Call(756, vec![10, 2, 3, 4, 5, 6, 7, 8, 9], 2, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![13, 11, 12]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_758() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(84, vec![2], 9, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(750, vec![12, 11], 3, false), Op::Call(750, vec![13, 30], 3, false), Op::Call(747, vec![14, 33], 10, false), Op::Call(748, vec![15, 43], 3, false), Op::Call(748, vec![16, 46], 3, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![50, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 47, 48, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 49]) }), (G::from_u64(1), Block { ops: vec![Op::Call(749, vec![12, 11], 3, false), Op::Call(747, vec![13, 30], 10, false), Op::Call(747, vec![14, 40], 10, false), Op::Call(747, vec![15, 50], 10, false), Op::Call(748, vec![16, 60], 3, false), Op::Call(757, vec![17, 63], 3, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![67, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 65, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 66]) }), (G::from_u64(2), Block { ops: vec![Op::Call(749, vec![12, 11], 3, false), Op::Call(749, vec![13, 30], 3, false), Op::Call(747, vec![14, 33], 10, false), Op::Call(747, vec![15, 43], 10, false), Op::Call(747, vec![16, 53], 10, false), Op::Call(747, vec![17, 63], 10, false), Op::Call(747, vec![18, 73], 10, false), Op::Call(748, vec![19, 83], 3, false), Op::Call(753, vec![20, 86], 3, false), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![90, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, 69, 70, 71, 72, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 87, 88, 89]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 90, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_759() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 9, false), Op::Call(758, vec![9], 55, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 65, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_760() -> Function { + Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(759, vec![0], 63, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(760, vec![72, 73, 74, 75, 76, 77, 78, 79, 80], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![83, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 81])], ctrl: Ctrl::Return(1, vec![84, 82]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 77, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_761() -> Function { + Function { body: Block { ops: vec![Op::Call(80, vec![0], 2, false), Op::Call(84, vec![2], 9, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(750, vec![12, 11], 3, false), Op::Call(750, vec![13, 30], 3, false), Op::Call(747, vec![14, 33], 10, false), Op::Call(748, vec![15, 43], 3, false), Op::Call(748, vec![16, 46], 3, false), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![50, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 47, 48, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 49]) }), (G::from_u64(1), Block { ops: vec![Op::Call(749, vec![12, 11], 3, false), Op::Call(749, vec![13, 30], 3, false), Op::Call(747, vec![14, 33], 10, false), Op::Call(747, vec![15, 43], 10, false), Op::Call(747, vec![16, 53], 10, false), Op::Call(747, vec![17, 63], 10, false), Op::Call(747, vec![18, 73], 10, false), Op::Call(748, vec![19, 83], 3, false), Op::Call(753, vec![20, 86], 3, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![90, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, 69, 70, 71, 72, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 87, 88, 89]) }), (G::from_u64(2), Block { ops: vec![Op::Call(749, vec![12, 11], 3, false), Op::Call(747, vec![13, 30], 10, false), Op::Call(748, vec![14, 40], 3, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![44, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 43]) }), (G::from_u64(3), Block { ops: vec![Op::Call(751, vec![12, 11], 3, false), Op::Call(747, vec![13, 30], 10, false), Op::Call(748, vec![14, 40], 3, false), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![44, 28, 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 43]) }), (G::from_u64(4), Block { ops: vec![Op::Call(747, vec![12, 11], 10, false), Op::Call(747, vec![13, 37], 10, false), Op::Call(748, vec![14, 47], 3, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 50]) }), (G::from_u64(5), Block { ops: vec![Op::Call(747, vec![12, 11], 10, false), Op::Call(748, vec![13, 37], 3, false), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![41, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 40]) }), (G::from_u64(6), Block { ops: vec![Op::Call(747, vec![12, 11], 10, false), Op::Call(748, vec![13, 37], 3, false), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![41, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 40]) }), (G::from_u64(7), Block { ops: vec![Op::Call(747, vec![12, 11], 10, false), Op::Call(748, vec![13, 37], 3, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![41, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 40]) }), (G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28])], ctrl: Ctrl::Yield(8, vec![29, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(84, vec![11], 9, false), Op::Call(760, vec![36, 28, 29, 30, 31, 32, 33, 34, 35], 2, false)], ctrl: Ctrl::Yield(9, vec![37, 38]) })].into_iter().collect(), None, 2, 11, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![30, 28, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 29]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 11, auxiliaries: 90, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_762() -> Function { + Function { body: Block { ops: vec![Op::Load(18, 0), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Call(35, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20], 1, false), Op::Call(23, vec![21], 1, false)], ctrl: Ctrl::Return(0, vec![22]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 22, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_763() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_764() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(763, vec![0], 1, false), Op::Call(763, vec![2], 1, false), Op::AssertEq(vec![3], vec![4], Some("Reveal: claimed definition kind != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_765() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(763, vec![0], 1, false), Op::Call(763, vec![2], 1, false), Op::AssertEq(vec![3], vec![4], Some("Reveal: claimed definition safety != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_766() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(113, vec![0], 1, false), Op::Call(113, vec![2], 1, false), Op::AssertEq(vec![3], vec![4], Some("Reveal: claimed quotient kind != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_767() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![0], vec![2], Some("Reveal: claimed flag != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_768() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![0, 1, 2, 3, 4, 5, 6, 7], vec![9, 10, 11, 12, 13, 14, 15, 16], Some("Reveal: claimed numeric field != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_769() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 0), Op::Load(32, 2), Op::AssertEq(vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34], vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66], Some("Reveal: claimed address field != real".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 65, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_770() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(762, vec![0], 1, false), Op::Load(32, 3), Op::Load(32, 2), Op::AssertEq(vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], vec![36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67], Some("Reveal: claimed expr hash != hash of the real expr".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 66, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_771() -> Function { + Function { body: Block { ops: vec![Op::Load(19, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(29, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(30, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![11, 12, 13, 14, 15, 16, 17, 18], vec![2, 3, 4, 5, 6, 7, 8, 9], Some("Reveal: claimed recursor rule index != its position".into())), Op::AssertEq(vec![30, 31, 32, 33, 34, 35, 36, 37], vec![19, 20, 21, 22, 23, 24, 25, 26], Some("Reveal: claimed recursor rule field count != real".into())), Op::Const(G::from_u64(0)), Op::Call(770, vec![38, 40, 27], 0, false), Op::Call(16, vec![2, 3, 4, 5, 6, 7, 8, 9], 8, false), Op::Call(771, vec![39, 28, 41, 42, 43, 44, 45, 46, 47, 48], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 39, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_772() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(771, vec![0, 2, 3, 3, 3, 3, 3, 3, 3, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 1, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_773() -> Function { + Function { body: Block { ops: vec![Op::Call(797, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 34, false)], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(49, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(767, vec![49, 9, 10], 0, false), Op::Call(768, vec![50, 51, 52, 53, 54, 55, 56, 57, 11, 12, 13, 14, 15, 16, 17, 18, 19], 0, false), Op::Call(768, vec![58, 59, 60, 61, 62, 63, 64, 65, 20, 21, 22, 23, 24, 25, 26, 27, 28], 0, false), Op::Call(768, vec![66, 67, 68, 69, 70, 71, 72, 73, 29, 30, 31, 32, 33, 34, 35, 36, 37], 0, false), Op::Call(768, vec![74, 75, 76, 77, 78, 79, 80, 81, 38, 39, 40, 41, 42, 43, 44, 45, 46], 0, false), Op::Call(770, vec![82, 47, 48], 0, false)], ctrl: Ctrl::Return(0, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 49, selectors: 1, auxiliaries: 35, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_774() -> Function { + Function { body: Block { ops: vec![Op::Load(50, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(773, vec![0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50], 0, false), Op::Call(774, vec![0, 51], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 51, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_775() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(774, vec![0, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 1, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_776() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(45, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![1, 46, 47], 0, false), Op::Call(765, vec![2, 48, 49], 0, false), Op::Call(768, vec![3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 56, 57, 58], 0, false), Op::Call(770, vec![11, 59, 60], 0, false), Op::Call(770, vec![12, 61, 62], 0, false)], ctrl: Ctrl::Return(0, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(767, vec![1, 46, 47], 0, false), Op::Call(768, vec![2, 3, 4, 5, 6, 7, 8, 9, 48, 49, 50, 51, 52, 53, 54, 55, 56], 0, false), Op::Call(768, vec![10, 11, 12, 13, 14, 15, 16, 17, 57, 58, 59, 60, 61, 62, 63, 64, 65], 0, false), Op::Call(768, vec![18, 19, 20, 21, 22, 23, 24, 25, 66, 67, 68, 69, 70, 71, 72, 73, 74], 0, false), Op::Call(770, vec![26, 75, 76], 0, false), Op::Call(775, vec![27, 77, 78], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(45, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(767, vec![1, 46, 47], 0, false), Op::Call(767, vec![2, 48, 49], 0, false), Op::Call(768, vec![3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 56, 57, 58], 0, false), Op::Call(768, vec![11, 12, 13, 14, 15, 16, 17, 18, 59, 60, 61, 62, 63, 64, 65, 66, 67], 0, false), Op::Call(768, vec![19, 20, 21, 22, 23, 24, 25, 26, 68, 69, 70, 71, 72, 73, 74, 75, 76], 0, false), Op::Call(768, vec![27, 28, 29, 30, 31, 32, 33, 34, 77, 78, 79, 80, 81, 82, 83, 84, 85], 0, false), Op::Call(768, vec![35, 36, 37, 38, 39, 40, 41, 42, 86, 87, 88, 89, 90, 91, 92, 93, 94], 0, false), Op::Call(770, vec![43, 95, 96], 0, false), Op::Call(772, vec![44, 97, 98], 0, false)], ctrl: Ctrl::Return(2, vec![]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 99, selectors: 3, auxiliaries: 1, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_777() -> Function { + Function { body: Block { ops: vec![Op::Load(64, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(794, vec![0, 3, 4, 5, 6, 7, 8, 9, 10], 45, false), Op::Call(776, vec![66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64], 0, false), Op::Call(777, vec![0, 65], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 110, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_778() -> Function { + Function { body: Block { ops: vec![Op::Call(293, vec![0], 48, false)], ctrl: Ctrl::Match(55, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![56, 2, 3], 0, false), Op::Call(765, vec![57, 4, 5], 0, false), Op::Call(768, vec![58, 59, 60, 61, 62, 63, 64, 65, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(770, vec![66, 15, 16], 0, false), Op::Call(770, vec![67, 17, 18], 0, false)], ctrl: Ctrl::Return(0, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(767, vec![56, 2, 3], 0, false), Op::Call(767, vec![57, 4, 5], 0, false), Op::Call(768, vec![58, 59, 60, 61, 62, 63, 64, 65, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(768, vec![66, 67, 68, 69, 70, 71, 72, 73, 15, 16, 17, 18, 19, 20, 21, 22, 23], 0, false), Op::Call(768, vec![74, 75, 76, 77, 78, 79, 80, 81, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false), Op::Call(768, vec![82, 83, 84, 85, 86, 87, 88, 89, 33, 34, 35, 36, 37, 38, 39, 40, 41], 0, false), Op::Call(768, vec![90, 91, 92, 93, 94, 95, 96, 97, 42, 43, 44, 45, 46, 47, 48, 49, 50], 0, false), Op::Call(770, vec![98, 51, 52], 0, false), Op::Call(772, vec![99, 53, 54], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(767, vec![56, 2, 3], 0, false), Op::Call(768, vec![57, 58, 59, 60, 61, 62, 63, 64, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false), Op::Call(770, vec![65, 13, 14], 0, false)], ctrl: Ctrl::Return(2, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(766, vec![56, 2, 3], 0, false), Op::Call(768, vec![57, 58, 59, 60, 61, 62, 63, 64, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false), Op::Call(770, vec![65, 13, 14], 0, false)], ctrl: Ctrl::Return(3, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(768, vec![64, 65, 66, 67, 68, 69, 70, 71, 11, 12, 13, 14, 15, 16, 17, 18, 19], 0, false), Op::Call(769, vec![72, 20, 21], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(769, vec![64, 11, 12], 0, false)], ctrl: Ctrl::Return(5, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(769, vec![64, 11, 12], 0, false)], ctrl: Ctrl::Return(6, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(56, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(769, vec![64, 11, 12], 0, false)], ctrl: Ctrl::Return(7, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(8), Block { ops: vec![Op::Call(777, vec![56, 2], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 55, selectors: 9, auxiliaries: 49, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_779() -> Function { + Function { body: Block { ops: vec![Op::Call(735, vec![0], 1, false), Op::Call(427, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![4], Some("Contains: target is not a leaf of the claimed tree".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_780() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(8, vec![0, 1, 2, 3, 4, 5, 6, 7]), Op::Call(5, vec![8, 9, 10], 1, false), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![43, 43, 43]), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8]), Op::Store(vec![12, 13, 14, 15, 16, 17, 12, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Call(26, vec![11, 44, 8, 8, 45, 46, 47], 1, false), Op::Call(25, vec![48], 32, false), Op::Const(G::from_u64(256)), Op::Mul(81, 50), Op::Const(G::from_u64(65536)), Op::Mul(83, 51), Op::Const(G::from_u64(16777216)), Op::Mul(85, 52), Op::Add(84, 86), Op::Add(82, 87), Op::Add(49, 88), Op::Mul(81, 54), Op::Mul(83, 55), Op::Mul(85, 56), Op::Add(91, 92), Op::Add(90, 93), Op::Add(53, 94), Op::Mul(81, 58), Op::Mul(83, 59), Op::Mul(85, 60), Op::Add(97, 98), Op::Add(96, 99), Op::Add(57, 100), Op::Mul(81, 62), Op::Mul(83, 63), Op::Mul(85, 64), Op::Add(103, 104), Op::Add(102, 105), Op::Add(61, 106), Op::Mul(81, 66), Op::Mul(83, 67), Op::Mul(85, 68), Op::Add(109, 110), Op::Add(108, 111), Op::Add(65, 112), Op::Mul(81, 70), Op::Mul(83, 71), Op::Mul(85, 72), Op::Add(115, 116), Op::Add(114, 117), Op::Add(69, 118), Op::Mul(81, 74), Op::Mul(83, 75), Op::Mul(85, 76), Op::Add(121, 122), Op::Add(120, 123), Op::Add(73, 124), Op::Mul(81, 78), Op::Mul(83, 79), Op::Mul(85, 80), Op::Add(127, 128), Op::Add(126, 129), Op::Add(77, 130), Op::AssertEq(vec![89, 95, 101, 107, 113, 119, 125, 131], vec![0, 1, 2, 3, 4, 5, 6, 7], Some("claim: bytes do not hash to the public claim digest".into())), Op::Call(82, vec![11], 10, false), Op::AssertEq(vec![132], vec![29], Some("claim: wrong TagN flag".into())), Op::Add(134, 135), Op::Add(142, 136), Op::Add(143, 137), Op::Add(144, 138), Op::Add(145, 139), Op::Add(146, 140), Op::AssertEq(vec![147], vec![8], Some("claim: TagN size exceeds a single byte".into())), Op::Call(80, vec![141], 2, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![148], vec![150], Some("claim: unsupported object format".into())), Op::Call(80, vec![149], 2, false)], ctrl: Ctrl::Match(133, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(99, vec![152], 2, false), Op::Call(746, vec![155], 3, false), Op::Load(3, 158), Op::AssertEq(vec![159, 160, 161], vec![153, 153, 153], Some("claim: trailing bytes".into()))], ctrl: Ctrl::Match(156, [(G::from_u64(1), Block { ops: vec![Op::Call(728, vec![154], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(735, vec![157], 1, false), Op::Const(G::from_u64(1)), Op::Call(736, vec![162, 163, 163, 163, 163, 163, 163], 6, false), Op::Const(G::from_u64(0)), Op::Call(738, vec![154, 163, 163, 163, 163, 163, 163, 164, 165, 166, 167, 168, 169, 170], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(99, vec![152], 2, false), Op::Call(746, vec![155], 3, false), Op::Load(3, 158), Op::AssertEq(vec![159, 160, 161], vec![153, 153, 153], Some("claim: trailing bytes".into())), Op::Call(741, vec![154, 156, 157], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(99, vec![152], 2, false), Op::Call(761, vec![155], 55, false), Op::Load(3, 210), Op::Const(G::from_u64(1)), Op::AssertEq(vec![211, 212, 213], vec![214, 214, 214], Some("claim: trailing bytes".into())), Op::Call(778, vec![154, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(99, vec![152], 2, false), Op::Call(99, vec![155], 2, false), Op::Load(3, 157), Op::Const(G::from_u64(1)), Op::AssertEq(vec![158, 159, 160], vec![161, 161, 161], Some("claim: trailing bytes".into())), Op::Call(779, vec![154, 156], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(2)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong resource validator identity".into())), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![154], vec![155], Some("claim: resource-v1 is not implemented by IxVM".into()))], ctrl: Ctrl::Return(5, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 6, auxiliaries: 115, lookups: 17 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_781() -> Function { + Function { body: Block { ops: vec![Op::Call(780, vec![0, 1, 2, 3, 4, 5, 6, 7], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_782() -> Function { + Function { body: Block { ops: vec![Op::Call(801, vec![0, 1], 1, false), Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_783() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![5, 1, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(783, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_784() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11, 11, 11, 11, 11, 11, 11, 11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(784, vec![10], 8, false), Op::Call(16, vec![11, 12, 13, 14, 15, 16, 17, 18], 8, false)], ctrl: Ctrl::Return(1, vec![19, 20, 21, 22, 23, 24, 25, 26]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 27, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_785() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(785, vec![5, 1], 1, false), Op::Store(vec![6, 3, 4, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_786() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4, 4, 4, 4, 4, 4, 4, 4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(786, vec![3], 8, false), Op::Call(16, vec![4, 5, 6, 7, 8, 9, 10, 11], 8, false)], ctrl: Ctrl::Return(1, vec![12, 13, 14, 15, 16, 17, 18, 19]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 20, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_787() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 5), Op::Load(6, 6), Op::U32LessThan(0, 3)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(787, vec![0, 8, 9, 10, 11, 12, 13, 7], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(0, 3)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(787, vec![0, 14, 15, 16, 17, 18, 19, 7], 1, false)], ctrl: Ctrl::Return(3, vec![22]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 22, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_788() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(806, vec![0, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_789() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(789, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_790() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(790, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 5)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_791() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![37, 37, 37, 37, 37, 37, 37, 37]) }), (G::from_u64(0), Block { ops: vec![Op::Call(791, vec![36], 8, false), Op::Call(16, vec![37, 38, 39, 40, 41, 42, 43, 44], 8, false)], ctrl: Ctrl::Return(1, vec![45, 46, 47, 48, 49, 50, 51, 52]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 53, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_792() -> Function { + Function { body: Block { ops: vec![Op::Call(801, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_793() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(793, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Add(11, 12)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_794() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(56, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54]) }), (G::from_u64(0), Block { ops: vec![Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(794, vec![55, 57, 58, 59, 60, 61, 62, 63, 64], 45, false)], ctrl: Ctrl::Return(1, vec![65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 102, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_795() -> Function { + Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![48, 48, 48, 48, 48, 48, 48, 48]) }), (G::from_u64(0), Block { ops: vec![Op::Call(795, vec![47], 8, false), Op::Call(16, vec![48, 49, 50, 51, 52, 53, 54, 55], 8, false)], ctrl: Ctrl::Return(1, vec![56, 57, 58, 59, 60, 61, 62, 63]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 64, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_796() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 12, 12, 12, 12, 12, 12, 12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(796, vec![11], 8, false), Op::Call(16, vec![12, 13, 14, 15, 16, 17, 18, 19], 8, false)], ctrl: Ctrl::Return(1, vec![20, 21, 22, 23, 24, 25, 26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_797() -> Function { + Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]) }), (G::from_u64(0), Block { ops: vec![Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(797, vec![44, 46, 47, 48, 49, 50, 51, 52, 53], 34, false)], ctrl: Ctrl::Return(1, vec![54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 80, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_798() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_799() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12, 12, 12, 12]), Op::Store(vec![11, 1, 2, 3, 4, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(799, vec![10, 1, 2, 3, 4], 1, false), Op::Store(vec![11, 6, 7, 8, 9, 12])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_800() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(800, vec![4, 7], 1, false), Op::Store(vec![5, 3, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_801() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(801, vec![0, 3], 1, false), Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_802() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(802, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_803() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(803, vec![3], 1, false), Op::Call(3, vec![4], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_804() -> Function { + Function { body: Block { ops: vec![Op::Call(807, vec![0, 1, 2, 3, 4, 5, 6, 7], 6, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14, 15, 10, 11, 12, 13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 7, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_805() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(805, vec![6], 1, false), Op::Const(G::from_u64(1)), Op::Add(7, 8)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_806() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(806, vec![4, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_807() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![8, 8, 0, 1, 10, 10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6), Op::Load(6, 7), Op::U32LessThan(0, 4)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(807, vec![0, 1, 8, 9, 10, 11, 12, 13], 6, false), Op::Call(808, vec![3, 4, 5, 21, 22, 23, 24, 25, 26, 14, 15, 16, 17, 18, 19], 6, false)], ctrl: Ctrl::Return(1, vec![27, 28, 29, 30, 31, 32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(0, 4)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![14, 15, 16, 17, 18, 19])], ctrl: Ctrl::Return(2, vec![22, 3, 0, 1, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(807, vec![0, 1, 14, 15, 16, 17, 18, 19], 6, false), Op::Call(808, vec![3, 4, 5, 8, 9, 10, 11, 12, 13, 22, 23, 24, 25, 26, 27], 6, false)], ctrl: Ctrl::Return(3, vec![28, 29, 30, 31, 32, 33]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 33, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_808() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Call(809, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 6, false)], ctrl: Ctrl::Return(0, vec![15, 16, 17, 18, 19, 20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![3, 4, 5, 6, 7, 8]), Op::Store(vec![9, 10, 11, 12, 13, 14])], ctrl: Ctrl::Return(1, vec![15, 0, 1, 2, 16, 17]) }))) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_809() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 21, 16, 17, 18, 19]), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![20, 21, 0, 1, 7, 23])], ctrl: Ctrl::Return(0, vec![20, 20, 4, 5, 22, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 7)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 27, 4, 5, 6, 24]), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![26, 27, 0, 1, 25, 29])], ctrl: Ctrl::Return(1, vec![26, 26, 22, 23, 28, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(2, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(3, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(4, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(5, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(6, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(7, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(8, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(9, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(10, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(11, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(12, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(13, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(14, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(15, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(16, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(17, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(18, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(19, vec![26, 27, 0, 1, 28, 29]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 7)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 27, 4, 5, 6, 24]), Op::Store(vec![8, 9, 10, 11, 12, 13]), Op::Store(vec![26, 27, 0, 1, 25, 29])], ctrl: Ctrl::Return(20, vec![26, 26, 22, 23, 28, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(21, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(22, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(23, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(24, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(25, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(26, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(27, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(28, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(29, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![32, 33, 0, 1, 34, 30]), Op::Store(vec![32, 33, 10, 11, 31, 13])], ctrl: Ctrl::Return(30, vec![32, 32, 28, 29, 35, 36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(31, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(32, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(33, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(32, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![38, 39, 0, 1, 40, 12]), Op::Store(vec![38, 39, 34, 35, 36, 37])], ctrl: Ctrl::Return(34, vec![38, 38, 10, 11, 41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(35, vec![38, 39, 0, 1, 40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(36, vec![38, 39, 0, 1, 40, 41]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(37, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(38, vec![26, 27, 0, 1, 28, 29]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![20, 21, 0, 1, 22, 18]), Op::Store(vec![20, 21, 10, 11, 19, 13])], ctrl: Ctrl::Return(39, vec![20, 20, 16, 17, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(40, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(41, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(42, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(43, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(44, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(45, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(46, vec![14, 15, 0, 1, 16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(47, vec![14, 15, 0, 1, 16, 17]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![20, 21, 0, 1, 22, 18]), Op::Store(vec![20, 21, 10, 11, 19, 13])], ctrl: Ctrl::Return(48, vec![20, 20, 16, 17, 23, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(49, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(50, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(51, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(6, 13)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![26, 27, 0, 1, 28, 12]), Op::Store(vec![26, 27, 22, 23, 24, 25])], ctrl: Ctrl::Return(52, vec![26, 26, 10, 11, 29, 30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(53, vec![26, 27, 0, 1, 28, 29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(54, vec![26, 27, 0, 1, 28, 29]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(55, vec![14, 15, 0, 1, 16, 17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 3, 4, 5, 6, 7]), Op::Store(vec![8, 9, 10, 11, 12, 13])], ctrl: Ctrl::Return(56, vec![14, 15, 0, 1, 16, 17]) }))) }))) }, layout: FunctionLayout { input_size: 14, selectors: 57, auxiliaries: 31, lookups: 8 }, entry: false, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21(), expected_function_22(), expected_function_23(), expected_function_24(), expected_function_25(), expected_function_26(), expected_function_27(), expected_function_28(), expected_function_29(), expected_function_30(), expected_function_31(), expected_function_32(), expected_function_33(), expected_function_34(), expected_function_35(), expected_function_36(), expected_function_37(), expected_function_38(), expected_function_39(), expected_function_40(), expected_function_41(), expected_function_42(), expected_function_43(), expected_function_44(), expected_function_45(), expected_function_46(), expected_function_47(), expected_function_48(), expected_function_49(), expected_function_50(), expected_function_51(), expected_function_52(), expected_function_53(), expected_function_54(), expected_function_55(), expected_function_56(), expected_function_57(), expected_function_58(), expected_function_59(), expected_function_60(), expected_function_61(), expected_function_62(), expected_function_63(), expected_function_64(), expected_function_65(), expected_function_66(), expected_function_67(), expected_function_68(), expected_function_69(), expected_function_70(), expected_function_71(), expected_function_72(), expected_function_73(), expected_function_74(), expected_function_75(), expected_function_76(), expected_function_77(), expected_function_78(), expected_function_79(), expected_function_80(), expected_function_81(), expected_function_82(), expected_function_83(), expected_function_84(), expected_function_85(), expected_function_86(), expected_function_87(), expected_function_88(), expected_function_89(), expected_function_90(), expected_function_91(), expected_function_92(), expected_function_93(), expected_function_94(), expected_function_95(), expected_function_96(), expected_function_97(), expected_function_98(), expected_function_99(), expected_function_100(), expected_function_101(), expected_function_102(), expected_function_103(), expected_function_104(), expected_function_105(), expected_function_106(), expected_function_107(), expected_function_108(), expected_function_109(), expected_function_110(), expected_function_111(), expected_function_112(), expected_function_113(), expected_function_114(), expected_function_115(), expected_function_116(), expected_function_117(), expected_function_118(), expected_function_119(), expected_function_120(), expected_function_121(), expected_function_122(), expected_function_123(), expected_function_124(), expected_function_125(), expected_function_126(), expected_function_127(), expected_function_128(), expected_function_129(), expected_function_130(), expected_function_131(), expected_function_132(), expected_function_133(), expected_function_134(), expected_function_135(), expected_function_136(), expected_function_137(), expected_function_138(), expected_function_139(), expected_function_140(), expected_function_141(), expected_function_142(), expected_function_143(), expected_function_144(), expected_function_145(), expected_function_146(), expected_function_147(), expected_function_148(), expected_function_149(), expected_function_150(), expected_function_151(), expected_function_152(), expected_function_153(), expected_function_154(), expected_function_155(), expected_function_156(), expected_function_157(), expected_function_158(), expected_function_159(), expected_function_160(), expected_function_161(), expected_function_162(), expected_function_163(), expected_function_164(), expected_function_165(), expected_function_166(), expected_function_167(), expected_function_168(), expected_function_169(), expected_function_170(), expected_function_171(), expected_function_172(), expected_function_173(), expected_function_174(), expected_function_175(), expected_function_176(), expected_function_177(), expected_function_178(), expected_function_179(), expected_function_180(), expected_function_181(), expected_function_182(), expected_function_183(), expected_function_184(), expected_function_185(), expected_function_186(), expected_function_187(), expected_function_188(), expected_function_189(), expected_function_190(), expected_function_191(), expected_function_192(), expected_function_193(), expected_function_194(), expected_function_195(), expected_function_196(), expected_function_197(), expected_function_198(), expected_function_199(), expected_function_200(), expected_function_201(), expected_function_202(), expected_function_203(), expected_function_204(), expected_function_205(), expected_function_206(), expected_function_207(), expected_function_208(), expected_function_209(), expected_function_210(), expected_function_211(), expected_function_212(), expected_function_213(), expected_function_214(), expected_function_215(), expected_function_216(), expected_function_217(), expected_function_218(), expected_function_219(), expected_function_220(), expected_function_221(), expected_function_222(), expected_function_223(), expected_function_224(), expected_function_225(), expected_function_226(), expected_function_227(), expected_function_228(), expected_function_229(), expected_function_230(), expected_function_231(), expected_function_232(), expected_function_233(), expected_function_234(), expected_function_235(), expected_function_236(), expected_function_237(), expected_function_238(), expected_function_239(), expected_function_240(), expected_function_241(), expected_function_242(), expected_function_243(), expected_function_244(), expected_function_245(), expected_function_246(), expected_function_247(), expected_function_248(), expected_function_249(), expected_function_250(), expected_function_251(), expected_function_252(), expected_function_253(), expected_function_254(), expected_function_255(), expected_function_256(), expected_function_257(), expected_function_258(), expected_function_259(), expected_function_260(), expected_function_261(), expected_function_262(), expected_function_263(), expected_function_264(), expected_function_265(), expected_function_266(), expected_function_267(), expected_function_268(), expected_function_269(), expected_function_270(), expected_function_271(), expected_function_272(), expected_function_273(), expected_function_274(), expected_function_275(), expected_function_276(), expected_function_277(), expected_function_278(), expected_function_279(), expected_function_280(), expected_function_281(), expected_function_282(), expected_function_283(), expected_function_284(), expected_function_285(), expected_function_286(), expected_function_287(), expected_function_288(), expected_function_289(), expected_function_290(), expected_function_291(), expected_function_292(), expected_function_293(), expected_function_294(), expected_function_295(), expected_function_296(), expected_function_297(), expected_function_298(), expected_function_299(), expected_function_300(), expected_function_301(), expected_function_302(), expected_function_303(), expected_function_304(), expected_function_305(), expected_function_306(), expected_function_307(), expected_function_308(), expected_function_309(), expected_function_310(), expected_function_311(), expected_function_312(), expected_function_313(), expected_function_314(), expected_function_315(), expected_function_316(), expected_function_317(), expected_function_318(), expected_function_319(), expected_function_320(), expected_function_321(), expected_function_322(), expected_function_323(), expected_function_324(), expected_function_325(), expected_function_326(), expected_function_327(), expected_function_328(), expected_function_329(), expected_function_330(), expected_function_331(), expected_function_332(), expected_function_333(), expected_function_334(), expected_function_335(), expected_function_336(), expected_function_337(), expected_function_338(), expected_function_339(), expected_function_340(), expected_function_341(), expected_function_342(), expected_function_343(), expected_function_344(), expected_function_345(), expected_function_346(), expected_function_347(), expected_function_348(), expected_function_349(), expected_function_350(), expected_function_351(), expected_function_352(), expected_function_353(), expected_function_354(), expected_function_355(), expected_function_356(), expected_function_357(), expected_function_358(), expected_function_359(), expected_function_360(), expected_function_361(), expected_function_362(), expected_function_363(), expected_function_364(), expected_function_365(), expected_function_366(), expected_function_367(), expected_function_368(), expected_function_369(), expected_function_370(), expected_function_371(), expected_function_372(), expected_function_373(), expected_function_374(), expected_function_375(), expected_function_376(), expected_function_377(), expected_function_378(), expected_function_379(), expected_function_380(), expected_function_381(), expected_function_382(), expected_function_383(), expected_function_384(), expected_function_385(), expected_function_386(), expected_function_387(), expected_function_388(), expected_function_389(), expected_function_390(), expected_function_391(), expected_function_392(), expected_function_393(), expected_function_394(), expected_function_395(), expected_function_396(), expected_function_397(), expected_function_398(), expected_function_399(), expected_function_400(), expected_function_401(), expected_function_402(), expected_function_403(), expected_function_404(), expected_function_405(), expected_function_406(), expected_function_407(), expected_function_408(), expected_function_409(), expected_function_410(), expected_function_411(), expected_function_412(), expected_function_413(), expected_function_414(), expected_function_415(), expected_function_416(), expected_function_417(), expected_function_418(), expected_function_419(), expected_function_420(), expected_function_421(), expected_function_422(), expected_function_423(), expected_function_424(), expected_function_425(), expected_function_426(), expected_function_427(), expected_function_428(), expected_function_429(), expected_function_430(), expected_function_431(), expected_function_432(), expected_function_433(), expected_function_434(), expected_function_435(), expected_function_436(), expected_function_437(), expected_function_438(), expected_function_439(), expected_function_440(), expected_function_441(), expected_function_442(), expected_function_443(), expected_function_444(), expected_function_445(), expected_function_446(), expected_function_447(), expected_function_448(), expected_function_449(), expected_function_450(), expected_function_451(), expected_function_452(), expected_function_453(), expected_function_454(), expected_function_455(), expected_function_456(), expected_function_457(), expected_function_458(), expected_function_459(), expected_function_460(), expected_function_461(), expected_function_462(), expected_function_463(), expected_function_464(), expected_function_465(), expected_function_466(), expected_function_467(), expected_function_468(), expected_function_469(), expected_function_470(), expected_function_471(), expected_function_472(), expected_function_473(), expected_function_474(), expected_function_475(), expected_function_476(), expected_function_477(), expected_function_478(), expected_function_479(), expected_function_480(), expected_function_481(), expected_function_482(), expected_function_483(), expected_function_484(), expected_function_485(), expected_function_486(), expected_function_487(), expected_function_488(), expected_function_489(), expected_function_490(), expected_function_491(), expected_function_492(), expected_function_493(), expected_function_494(), expected_function_495(), expected_function_496(), expected_function_497(), expected_function_498(), expected_function_499(), expected_function_500(), expected_function_501(), expected_function_502(), expected_function_503(), expected_function_504(), expected_function_505(), expected_function_506(), expected_function_507(), expected_function_508(), expected_function_509(), expected_function_510(), expected_function_511(), expected_function_512(), expected_function_513(), expected_function_514(), expected_function_515(), expected_function_516(), expected_function_517(), expected_function_518(), expected_function_519(), expected_function_520(), expected_function_521(), expected_function_522(), expected_function_523(), expected_function_524(), expected_function_525(), expected_function_526(), expected_function_527(), expected_function_528(), expected_function_529(), expected_function_530(), expected_function_531(), expected_function_532(), expected_function_533(), expected_function_534(), expected_function_535(), expected_function_536(), expected_function_537(), expected_function_538(), expected_function_539(), expected_function_540(), expected_function_541(), expected_function_542(), expected_function_543(), expected_function_544(), expected_function_545(), expected_function_546(), expected_function_547(), expected_function_548(), expected_function_549(), expected_function_550(), expected_function_551(), expected_function_552(), expected_function_553(), expected_function_554(), expected_function_555(), expected_function_556(), expected_function_557(), expected_function_558(), expected_function_559(), expected_function_560(), expected_function_561(), expected_function_562(), expected_function_563(), expected_function_564(), expected_function_565(), expected_function_566(), expected_function_567(), expected_function_568(), expected_function_569(), expected_function_570(), expected_function_571(), expected_function_572(), expected_function_573(), expected_function_574(), expected_function_575(), expected_function_576(), expected_function_577(), expected_function_578(), expected_function_579(), expected_function_580(), expected_function_581(), expected_function_582(), expected_function_583(), expected_function_584(), expected_function_585(), expected_function_586(), expected_function_587(), expected_function_588(), expected_function_589(), expected_function_590(), expected_function_591(), expected_function_592(), expected_function_593(), expected_function_594(), expected_function_595(), expected_function_596(), expected_function_597(), expected_function_598(), expected_function_599(), expected_function_600(), expected_function_601(), expected_function_602(), expected_function_603(), expected_function_604(), expected_function_605(), expected_function_606(), expected_function_607(), expected_function_608(), expected_function_609(), expected_function_610(), expected_function_611(), expected_function_612(), expected_function_613(), expected_function_614(), expected_function_615(), expected_function_616(), expected_function_617(), expected_function_618(), expected_function_619(), expected_function_620(), expected_function_621(), expected_function_622(), expected_function_623(), expected_function_624(), expected_function_625(), expected_function_626(), expected_function_627(), expected_function_628(), expected_function_629(), expected_function_630(), expected_function_631(), expected_function_632(), expected_function_633(), expected_function_634(), expected_function_635(), expected_function_636(), expected_function_637(), expected_function_638(), expected_function_639(), expected_function_640(), expected_function_641(), expected_function_642(), expected_function_643(), expected_function_644(), expected_function_645(), expected_function_646(), expected_function_647(), expected_function_648(), expected_function_649(), expected_function_650(), expected_function_651(), expected_function_652(), expected_function_653(), expected_function_654(), expected_function_655(), expected_function_656(), expected_function_657(), expected_function_658(), expected_function_659(), expected_function_660(), expected_function_661(), expected_function_662(), expected_function_663(), expected_function_664(), expected_function_665(), expected_function_666(), expected_function_667(), expected_function_668(), expected_function_669(), expected_function_670(), expected_function_671(), expected_function_672(), expected_function_673(), expected_function_674(), expected_function_675(), expected_function_676(), expected_function_677(), expected_function_678(), expected_function_679(), expected_function_680(), expected_function_681(), expected_function_682(), expected_function_683(), expected_function_684(), expected_function_685(), expected_function_686(), expected_function_687(), expected_function_688(), expected_function_689(), expected_function_690(), expected_function_691(), expected_function_692(), expected_function_693(), expected_function_694(), expected_function_695(), expected_function_696(), expected_function_697(), expected_function_698(), expected_function_699(), expected_function_700(), expected_function_701(), expected_function_702(), expected_function_703(), expected_function_704(), expected_function_705(), expected_function_706(), expected_function_707(), expected_function_708(), expected_function_709(), expected_function_710(), expected_function_711(), expected_function_712(), expected_function_713(), expected_function_714(), expected_function_715(), expected_function_716(), expected_function_717(), expected_function_718(), expected_function_719(), expected_function_720(), expected_function_721(), expected_function_722(), expected_function_723(), expected_function_724(), expected_function_725(), expected_function_726(), expected_function_727(), expected_function_728(), expected_function_729(), expected_function_730(), expected_function_731(), expected_function_732(), expected_function_733(), expected_function_734(), expected_function_735(), expected_function_736(), expected_function_737(), expected_function_738(), expected_function_739(), expected_function_740(), expected_function_741(), expected_function_742(), expected_function_743(), expected_function_744(), expected_function_745(), expected_function_746(), expected_function_747(), expected_function_748(), expected_function_749(), expected_function_750(), expected_function_751(), expected_function_752(), expected_function_753(), expected_function_754(), expected_function_755(), expected_function_756(), expected_function_757(), expected_function_758(), expected_function_759(), expected_function_760(), expected_function_761(), expected_function_762(), expected_function_763(), expected_function_764(), expected_function_765(), expected_function_766(), expected_function_767(), expected_function_768(), expected_function_769(), expected_function_770(), expected_function_771(), expected_function_772(), expected_function_773(), expected_function_774(), expected_function_775(), expected_function_776(), expected_function_777(), expected_function_778(), expected_function_779(), expected_function_780(), expected_function_781(), expected_function_782(), expected_function_783(), expected_function_784(), expected_function_785(), expected_function_786(), expected_function_787(), expected_function_788(), expected_function_789(), expected_function_790(), expected_function_791(), expected_function_792(), expected_function_793(), expected_function_794(), expected_function_795(), expected_function_796(), expected_function_797(), expected_function_798(), expected_function_799(), expected_function_800(), expected_function_801(), expected_function_802(), expected_function_803(), expected_function_804(), expected_function_805(), expected_function_806(), expected_function_807(), expected_function_808(), expected_function_809()], memory_sizes: vec![2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 18, 19, 32, 34, 36, 47, 50, 64], circuits: vec![Circuit { members: vec![0, 354, 356, 494], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 7 } }, Circuit { members: vec![1, 110, 287, 288, 295, 298, 596, 635, 642, 651, 691], layout: FunctionLayout { input_size: 7, selectors: 40, auxiliaries: 72, lookups: 20 } }, Circuit { members: vec![2], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 66, lookups: 4 } }, Circuit { members: vec![3], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![5], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![6], layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![14, 16, 113, 147, 194, 229, 285, 286, 393, 394, 395, 603], layout: FunctionLayout { input_size: 16, selectors: 31, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![15, 230, 536, 719], layout: FunctionLayout { input_size: 16, selectors: 25, auxiliaries: 22, lookups: 16 } }, Circuit { members: vec![17, 18], layout: FunctionLayout { input_size: 8, selectors: 10, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![22, 72, 96, 97, 278, 447, 625, 686, 695, 703, 710, 723], layout: FunctionLayout { input_size: 33, selectors: 35, auxiliaries: 38, lookups: 8 } }, Circuit { members: vec![23, 115, 120, 477, 595, 643, 644, 724], layout: FunctionLayout { input_size: 2, selectors: 26, auxiliaries: 51, lookups: 8 } }, Circuit { members: vec![24, 300, 301, 303, 305, 659, 780], layout: FunctionLayout { input_size: 34, selectors: 25, auxiliaries: 142, lookups: 17 } }, Circuit { members: vec![25, 29, 124], layout: FunctionLayout { input_size: 6, selectors: 17, auxiliaries: 143, lookups: 9 } }, Circuit { members: vec![26], layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![27], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![28], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![30], layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 } }, Circuit { members: vec![34], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![35, 302, 658, 735, 738, 759, 760, 769, 777, 795, 797], layout: FunctionLayout { input_size: 19, selectors: 42, auxiliaries: 110, lookups: 9 } }, Circuit { members: vec![36, 201, 236, 246, 277, 569, 571, 582, 586, 587, 592, 593, 656, 768, 785, 804], layout: FunctionLayout { input_size: 17, selectors: 38, auxiliaries: 8, lookups: 7 } }, Circuit { members: vec![39, 37, 71, 284, 344, 473, 497, 513, 623, 631, 788], layout: FunctionLayout { input_size: 17, selectors: 32, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![38, 56, 63, 73, 151, 152, 297, 572, 584, 652, 711, 736, 739, 740, 762, 808], layout: FunctionLayout { input_size: 46, selectors: 38, auxiliaries: 22, lookups: 9 } }, Circuit { members: vec![40], layout: FunctionLayout { input_size: 11, selectors: 2, auxiliaries: 13, lookups: 5 } }, Circuit { members: vec![41], layout: FunctionLayout { input_size: 11, selectors: 7, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![42, 64, 350, 558, 567, 577, 578, 585, 589, 654, 655, 662, 753, 757, 793], layout: FunctionLayout { input_size: 3, selectors: 40, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![43], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 } }, Circuit { members: vec![44], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![45], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![46, 156, 216, 557, 562, 732, 733, 737, 747, 748, 749, 750, 751, 764, 765, 766], layout: FunctionLayout { input_size: 8, selectors: 32, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![47, 48, 49, 50, 51, 52, 62, 68, 70, 241, 574, 590, 752, 771, 787, 807], layout: FunctionLayout { input_size: 35, selectors: 37, auxiliaries: 42, lookups: 11 } }, Circuit { members: vec![53, 138, 212, 267, 682, 683], layout: FunctionLayout { input_size: 26, selectors: 37, auxiliaries: 73, lookups: 40 } }, Circuit { members: vec![61, 54, 196, 197, 220, 223, 227, 235, 237, 550, 554, 763, 767, 772, 775, 779], layout: FunctionLayout { input_size: 4, selectors: 34, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![55, 57, 66, 67, 69, 74, 154, 155, 564, 646, 660, 755, 774, 784, 791, 796], layout: FunctionLayout { input_size: 12, selectors: 36, auxiliaries: 53, lookups: 6 } }, Circuit { members: vec![58, 109, 117, 594, 634, 663, 681, 693, 697, 713, 725, 786], layout: FunctionLayout { input_size: 13, selectors: 37, auxiliaries: 53, lookups: 10 } }, Circuit { members: vec![59, 60, 76, 136, 271, 304, 315, 425, 427, 474, 664, 667, 673, 680, 709], layout: FunctionLayout { input_size: 3, selectors: 38, auxiliaries: 16, lookups: 9 } }, Circuit { members: vec![65, 248, 547, 556, 573, 575, 754, 756, 770, 773, 776, 778], layout: FunctionLayout { input_size: 99, selectors: 40, auxiliaries: 80, lookups: 33 } }, Circuit { members: vec![75, 79, 289, 290, 292, 726, 731], layout: FunctionLayout { input_size: 50, selectors: 27, auxiliaries: 15, lookups: 8 } }, Circuit { members: vec![77, 78, 135, 517, 611, 621, 645, 666, 674, 690, 705, 715, 746, 805], layout: FunctionLayout { input_size: 6, selectors: 24, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![80, 140, 380, 487, 608], layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![81], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![82], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 } }, Circuit { members: vec![83, 119, 336, 414, 416], layout: FunctionLayout { input_size: 2, selectors: 13, auxiliaries: 24, lookups: 9 } }, Circuit { members: vec![84], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 14, lookups: 4 } }, Circuit { members: vec![85], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 4 } }, Circuit { members: vec![86], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 19, lookups: 3 } }, Circuit { members: vec![87], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 22, lookups: 6 } }, Circuit { members: vec![88], layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![89], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 } }, Circuit { members: vec![90], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![91], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 } }, Circuit { members: vec![92], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 } }, Circuit { members: vec![93, 94], layout: FunctionLayout { input_size: 9, selectors: 6, auxiliaries: 23, lookups: 7 } }, Circuit { members: vec![95], layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 } }, Circuit { members: vec![98, 130, 466], layout: FunctionLayout { input_size: 3, selectors: 19, auxiliaries: 42, lookups: 11 } }, Circuit { members: vec![99], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 } }, Circuit { members: vec![100], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![101, 340, 409, 432, 471, 489, 490], layout: FunctionLayout { input_size: 9, selectors: 29, auxiliaries: 24, lookups: 10 } }, Circuit { members: vec![102], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![106, 111, 296, 355, 484, 492, 597, 633, 678, 696, 707], layout: FunctionLayout { input_size: 12, selectors: 37, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![107, 270, 282, 464], layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 19, lookups: 8 } }, Circuit { members: vec![112, 114, 210, 213, 258, 349, 400, 406, 422, 479, 606], layout: FunctionLayout { input_size: 4, selectors: 33, auxiliaries: 52, lookups: 10 } }, Circuit { members: vec![116, 121, 293, 307, 730], layout: FunctionLayout { input_size: 9, selectors: 9, auxiliaries: 88, lookups: 6 } }, Circuit { members: vec![118, 144, 463, 475, 720], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![122, 728], layout: FunctionLayout { input_size: 2, selectors: 15, auxiliaries: 55, lookups: 6 } }, Circuit { members: vec![125], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![126, 272, 280, 291, 326, 330, 544, 685, 694], layout: FunctionLayout { input_size: 6, selectors: 39, auxiliaries: 29, lookups: 10 } }, Circuit { members: vec![127], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 41, lookups: 7 } }, Circuit { members: vec![128], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![129, 276, 327, 541, 626, 636, 641, 677, 684, 689, 714], layout: FunctionLayout { input_size: 18, selectors: 37, auxiliaries: 24, lookups: 16 } }, Circuit { members: vec![131, 268, 333, 337, 363, 410], layout: FunctionLayout { input_size: 2, selectors: 21, auxiliaries: 17, lookups: 10 } }, Circuit { members: vec![132], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 } }, Circuit { members: vec![133], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![134, 279, 341, 377, 649, 668, 671, 676, 699, 702, 716, 717, 782], layout: FunctionLayout { input_size: 4, selectors: 29, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![141], layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![142], layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 } }, Circuit { members: vec![143], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![145, 149, 273, 612, 632, 700, 712], layout: FunctionLayout { input_size: 10, selectors: 21, auxiliaries: 21, lookups: 17 } }, Circuit { members: vec![146, 148, 157, 209, 403, 419, 421, 423, 539, 639, 640], layout: FunctionLayout { input_size: 6, selectors: 30, auxiliaries: 19, lookups: 6 } }, Circuit { members: vec![150, 153, 199, 233, 265, 404, 412, 548, 576], layout: FunctionLayout { input_size: 16, selectors: 37, auxiliaries: 31, lookups: 22 } }, Circuit { members: vec![158, 159, 160, 174, 182, 184, 190, 191, 192, 217, 218, 219, 224, 225, 226, 228], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![161, 162, 187, 188, 203, 204, 207, 391, 525, 526, 527, 529, 530, 531, 532, 604], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![163, 165, 166, 167, 168, 169, 170, 171, 172, 202, 205, 206, 390, 533, 534, 535], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![164, 173, 175, 176, 177, 178, 179, 180, 181, 183, 185, 186, 392, 522, 523, 524], layout: FunctionLayout { input_size: 0, selectors: 16, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![189, 193, 256, 306, 309, 318, 516, 601, 614, 622, 679, 708], layout: FunctionLayout { input_size: 4, selectors: 40, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![195, 320, 353, 371, 600], layout: FunctionLayout { input_size: 4, selectors: 18, auxiliaries: 16, lookups: 11 } }, Circuit { members: vec![198, 231, 239, 314, 317], layout: FunctionLayout { input_size: 3, selectors: 37, auxiliaries: 41, lookups: 28 } }, Circuit { members: vec![200, 215, 240, 247, 261, 262, 316, 328, 549, 570, 741], layout: FunctionLayout { input_size: 4, selectors: 39, auxiliaries: 18, lookups: 12 } }, Circuit { members: vec![208, 255, 325, 397, 480, 615], layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 11, lookups: 7 } }, Circuit { members: vec![211, 232, 245, 263, 405, 546, 565, 581, 588], layout: FunctionLayout { input_size: 16, selectors: 40, auxiliaries: 33, lookups: 17 } }, Circuit { members: vec![214, 275, 310, 319, 540, 542], layout: FunctionLayout { input_size: 4, selectors: 31, auxiliaries: 20, lookups: 16 } }, Circuit { members: vec![221, 222, 528, 551, 552, 553, 555], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![234, 254, 312, 321, 609, 618, 620, 672, 806], layout: FunctionLayout { input_size: 4, selectors: 30, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![238, 253, 264, 313, 415, 627], layout: FunctionLayout { input_size: 10, selectors: 27, auxiliaries: 35, lookups: 25 } }, Circuit { members: vec![242, 342, 362], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![244, 561, 566, 653, 734], layout: FunctionLayout { input_size: 2, selectors: 40, auxiliaries: 13, lookups: 8 } }, Circuit { members: vec![251, 299, 661, 692, 758, 761, 794], layout: FunctionLayout { input_size: 10, selectors: 40, auxiliaries: 109, lookups: 51 } }, Circuit { members: vec![257, 351, 537, 538, 607, 628, 638, 665, 698], layout: FunctionLayout { input_size: 7, selectors: 38, auxiliaries: 20, lookups: 10 } }, Circuit { members: vec![259, 322, 359, 372, 420, 424, 426, 605, 637], layout: FunctionLayout { input_size: 5, selectors: 38, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![260, 559, 560, 563, 580, 591, 647, 648, 669, 799], layout: FunctionLayout { input_size: 6, selectors: 40, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![266], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![269, 411, 485, 495, 543, 545, 687, 688, 701, 704], layout: FunctionLayout { input_size: 13, selectors: 37, auxiliaries: 50, lookups: 26 } }, Circuit { members: vec![281, 332, 343, 368, 413, 462, 613, 616], layout: FunctionLayout { input_size: 5, selectors: 26, auxiliaries: 13, lookups: 7 } }, Circuit { members: vec![283], layout: FunctionLayout { input_size: 5, selectors: 12, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![308, 323, 345, 398, 478], layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![311, 324, 399, 418, 519], layout: FunctionLayout { input_size: 9, selectors: 36, auxiliaries: 43, lookups: 24 } }, Circuit { members: vec![329, 331, 334, 417, 445, 448, 488, 514, 518, 718, 802], layout: FunctionLayout { input_size: 7, selectors: 34, auxiliaries: 12, lookups: 6 } }, Circuit { members: vec![335, 381, 385, 482, 629, 630, 706], layout: FunctionLayout { input_size: 5, selectors: 35, auxiliaries: 13, lookups: 6 } }, Circuit { members: vec![338, 446, 468, 515], layout: FunctionLayout { input_size: 3, selectors: 21, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![339, 460, 467], layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![346, 461, 476], layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![347], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![348], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![352], layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![357], layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 17, lookups: 14 } }, Circuit { members: vec![358, 481, 599], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![361, 493], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 18, lookups: 10 } }, Circuit { members: vec![364, 408], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 18, lookups: 13 } }, Circuit { members: vec![365], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![366], layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![367], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![369], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![370], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![373], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![374], layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 12, lookups: 9 } }, Circuit { members: vec![375], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 11, lookups: 4 } }, Circuit { members: vec![376, 452], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![378], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 5 } }, Circuit { members: vec![379], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![382], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![383], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 } }, Circuit { members: vec![384], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![386], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 12, lookups: 5 } }, Circuit { members: vec![387], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![388], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![389, 438], layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 28, lookups: 10 } }, Circuit { members: vec![396, 401], layout: FunctionLayout { input_size: 4, selectors: 33, auxiliaries: 61, lookups: 38 } }, Circuit { members: vec![402], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![407], layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 32, lookups: 10 } }, Circuit { members: vec![428], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![430], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![431], layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 14, lookups: 8 } }, Circuit { members: vec![433, 470], layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 19, lookups: 6 } }, Circuit { members: vec![434], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![436], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![437], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![439], layout: FunctionLayout { input_size: 5, selectors: 18, auxiliaries: 37, lookups: 13 } }, Circuit { members: vec![440], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![441, 442], layout: FunctionLayout { input_size: 12, selectors: 16, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![443, 472], layout: FunctionLayout { input_size: 3, selectors: 19, auxiliaries: 48, lookups: 15 } }, Circuit { members: vec![449], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 6 } }, Circuit { members: vec![450], layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 12, lookups: 11 } }, Circuit { members: vec![451, 457], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 16, lookups: 8 } }, Circuit { members: vec![453], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 9 } }, Circuit { members: vec![454], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![455], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![456], layout: FunctionLayout { input_size: 1, selectors: 12, auxiliaries: 23, lookups: 9 } }, Circuit { members: vec![459], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![465, 486, 491, 610, 617, 624], layout: FunctionLayout { input_size: 5, selectors: 16, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![469], layout: FunctionLayout { input_size: 4, selectors: 25, auxiliaries: 16, lookups: 6 } }, Circuit { members: vec![483], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![496], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![498], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![499], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 10, lookups: 9 } }, Circuit { members: vec![500], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 8 } }, Circuit { members: vec![501], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 7 } }, Circuit { members: vec![503], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 } }, Circuit { members: vec![505], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 9, lookups: 3 } }, Circuit { members: vec![506], layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 14, lookups: 8 } }, Circuit { members: vec![507], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![508], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![509], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 9, lookups: 7 } }, Circuit { members: vec![510], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 10, lookups: 3 } }, Circuit { members: vec![511], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 17, lookups: 11 } }, Circuit { members: vec![512], layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 21, lookups: 11 } }, Circuit { members: vec![520], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![521], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![568], layout: FunctionLayout { input_size: 9, selectors: 40, auxiliaries: 12, lookups: 7 } }, Circuit { members: vec![598], layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 19, lookups: 5 } }, Circuit { members: vec![602], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 20, lookups: 8 } }, Circuit { members: vec![721], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 7 } }, Circuit { members: vec![722], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![727], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![729], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 6, lookups: 5 } }, Circuit { members: vec![742], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 36, lookups: 5 } }, Circuit { members: vec![743], layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 2, lookups: 3 } }, Circuit { members: vec![744], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 82, lookups: 7 } }, Circuit { members: vec![745], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 37, lookups: 6 } }, Circuit { members: vec![781], layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 2 } }, Circuit { members: vec![783], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![789], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![790], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![792], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![798], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![800], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![801], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![803], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![809], layout: FunctionLayout { input_size: 14, selectors: 57, auxiliaries: 31, lookups: 8 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [71, 12, 39, 10, 46, 246, 206, 207, 13, 202, 124, 148, 208, 20, 179, 9, 173, 133, 63, 124, 82, 148, 252, 238, 173, 234, 55, 16, 172, 128, 84, 141], complete: false, expected: expected_program, functions: &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 16, lookups: 16 }, output_size: 9, seed_words: 17, schema: &SCHEMA_15, pack: |context, seed| { pack_15(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_15_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_15(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, output_size: 34, seed_words: 170, schema: &SCHEMA_24, pack: pack_24, pack_typed: pack_24_typed, write: write_24 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, output_size: 1, seed_words: 13, schema: &SCHEMA_26, pack: pack_26, pack_typed: pack_26_typed, write: write_26 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, output_size: 64, seed_words: 194, schema: &SCHEMA_27, pack: pack_27, pack_typed: pack_27_typed, write: write_27 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, output_size: 1, seed_words: 158, schema: &SCHEMA_30, pack: pack_30, pack_typed: pack_30_typed, write: |seed, offsets, row| { write_30(seed, offsets, row); Ok(()) } }), +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_34, pack: pack_34, pack_typed: pack_34_typed, write: |seed, offsets, row| { write_34(seed, offsets, row); Ok(()) } }), +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 3, lookups: 3 }, output_size: 1, seed_words: 12, schema: &SCHEMA_38, pack: pack_38, pack_typed: pack_38_typed, write: write_38 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 2, auxiliaries: 13, lookups: 5 }, output_size: 1, seed_words: 23, schema: &SCHEMA_40, pack: pack_40, pack_typed: pack_40_typed, write: write_40 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 7, auxiliaries: 12, lookups: 3 }, output_size: 1, seed_words: 22, schema: &SCHEMA_41, pack: pack_41, pack_typed: pack_41_typed, write: write_41 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 }, output_size: 1, seed_words: 5, schema: &SCHEMA_44, pack: pack_44, pack_typed: pack_44_typed, write: write_44 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, output_size: 8, seed_words: 53, schema: &SCHEMA_47, pack: pack_47, pack_typed: pack_47_typed, write: |seed, offsets, row| { write_47(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, output_size: 8, seed_words: 53, schema: &SCHEMA_48, pack: pack_48, pack_typed: pack_48_typed, write: |seed, offsets, row| { write_48(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, output_size: 8, seed_words: 53, schema: &SCHEMA_49, pack: pack_49, pack_typed: pack_49_typed, write: |seed, offsets, row| { write_49(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 39, lookups: 5 }, output_size: 1, seed_words: 58, schema: &SCHEMA_50, pack: pack_50, pack_typed: pack_50_typed, write: |seed, offsets, row| { write_50(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, output_size: 1, seed_words: 59, schema: &SCHEMA_51, pack: pack_51, pack_typed: pack_51_typed, write: |seed, offsets, row| { write_51(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, output_size: 1, seed_words: 59, schema: &SCHEMA_52, pack: pack_52, pack_typed: pack_52_typed, write: |seed, offsets, row| { write_52(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 26, lookups: 4 }, output_size: 8, seed_words: 35, schema: &SCHEMA_55, pack: pack_55, pack_typed: pack_55_typed, write: |seed, offsets, row| { write_55(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 19, lookups: 3 }, output_size: 9, seed_words: 28, schema: &SCHEMA_56, pack: pack_56, pack_typed: pack_56_typed, write: |seed, offsets, row| { write_56(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 5, auxiliaries: 22, lookups: 6 }, output_size: 1, seed_words: 32, schema: &SCHEMA_57, pack: pack_57, pack_typed: pack_57_typed, write: write_57 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 42, lookups: 8 }, output_size: 1, seed_words: 55, schema: &SCHEMA_62, pack: pack_62, pack_typed: pack_62_typed, write: |seed, offsets, row| { write_62(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 21, lookups: 4 }, output_size: 1, seed_words: 31, schema: &SCHEMA_63, pack: pack_63, pack_typed: pack_63_typed, write: |seed, offsets, row| { write_63(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, output_size: 1, seed_words: 33, schema: &SCHEMA_66, pack: pack_66, pack_typed: pack_66_typed, write: |seed, offsets, row| { write_66(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, output_size: 1, seed_words: 33, schema: &SCHEMA_67, pack: pack_67, pack_typed: pack_67_typed, write: |seed, offsets, row| { write_67(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 25, lookups: 8 }, output_size: 1, seed_words: 60, schema: &SCHEMA_68, pack: pack_68, pack_typed: pack_68_typed, write: |seed, offsets, row| { write_68(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 39, lookups: 4 }, output_size: 1, seed_words: 41, schema: &SCHEMA_69, pack: pack_69, pack_typed: pack_69_typed, write: write_69 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 28, selectors: 1, auxiliaries: 34, lookups: 10 }, output_size: 1, seed_words: 62, schema: &SCHEMA_70, pack: pack_70, pack_typed: pack_70_typed, write: |seed, offsets, row| { write_70(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 46, selectors: 3, auxiliaries: 3, lookups: 3 }, output_size: 1, seed_words: 49, schema: &SCHEMA_73, pack: pack_73, pack_typed: pack_73_typed, write: write_73 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 4 }, output_size: 1, seed_words: 52, schema: &SCHEMA_74, pack: pack_74, pack_typed: pack_74_typed, write: write_74 }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, output_size: 2, seed_words: 5, schema: &SCHEMA_80, pack: pack_80, pack_typed: pack_80_typed, write: write_80 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, output_size: 9, seed_words: 15, schema: &SCHEMA_81, pack: pack_81, pack_typed: pack_81_typed, write: write_81 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 }, output_size: 10, seed_words: 14, schema: &SCHEMA_82, pack: pack_82, pack_typed: pack_82_typed, write: write_82 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 14, lookups: 4 }, output_size: 9, seed_words: 14, schema: &SCHEMA_84, pack: pack_84, pack_typed: pack_84_typed, write: write_84 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 4 }, output_size: 9, seed_words: 13, schema: &SCHEMA_85, pack: pack_85, pack_typed: pack_85_typed, write: write_85 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 19, lookups: 3 }, output_size: 9, seed_words: 22, schema: &SCHEMA_86, pack: pack_86, pack_typed: pack_86_typed, write: write_86 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 }, output_size: 2, seed_words: 25, schema: &SCHEMA_88, pack: pack_88, pack_typed: pack_88_typed, write: write_88 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, output_size: 4, seed_words: 7, schema: &SCHEMA_91, pack: pack_91, pack_typed: pack_91_typed, write: |seed, offsets, row| { write_91(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 }, output_size: 6, seed_words: 9, schema: &SCHEMA_92, pack: pack_92, pack_typed: pack_92_typed, write: |seed, offsets, row| { write_92(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 }, output_size: 2, seed_words: 35, schema: &SCHEMA_95, pack: pack_95, pack_typed: pack_95_typed, write: write_95 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 }, output_size: 2, seed_words: 24, schema: &SCHEMA_100, pack: pack_100, pack_typed: pack_100_typed, write: write_100 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 8, auxiliaries: 46, lookups: 2 }, output_size: 46, seed_words: 48, schema: &SCHEMA_122, pack: pack_122, pack_typed: pack_122_typed, write: write_122 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, output_size: 2, seed_words: 9, schema: &SCHEMA_125, pack: pack_125, pack_typed: pack_125_typed, write: |seed, offsets, row| { write_125(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 41, lookups: 7 }, output_size: 1, seed_words: 44, schema: &SCHEMA_127, pack: pack_127, pack_typed: pack_127_typed, write: write_127 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 }, output_size: 2, seed_words: 16, schema: &SCHEMA_132, pack: pack_132, pack_typed: pack_132_typed, write: write_132 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, output_size: 1, seed_words: 5, schema: &SCHEMA_140, pack: pack_140, pack_typed: pack_140_typed, write: |seed, offsets, row| { write_140(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 }, output_size: 1, seed_words: 63, schema: &SCHEMA_142, pack: pack_142, pack_typed: pack_142_typed, write: write_142 }), +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 8, seed_words: 17, schema: &SCHEMA_151, pack: |context, seed| { pack_151(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_151_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_151(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 8, seed_words: 17, schema: &SCHEMA_152, pack: |context, seed| { pack_152(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_152_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_152(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, output_size: 1, seed_words: 33, schema: &SCHEMA_154, pack: pack_154, pack_typed: pack_154_typed, write: write_154 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, output_size: 1, seed_words: 33, schema: &SCHEMA_155, pack: pack_155, pack_typed: pack_155_typed, write: write_155 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 8, auxiliaries: 22, lookups: 15 }, output_size: 1, seed_words: 16, schema: &SCHEMA_230, pack: pack_230, pack_typed: pack_230_typed, write: |seed, offsets, row| { write_230(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 31, lookups: 10 }, output_size: 1, seed_words: 32, schema: &SCHEMA_241, pack: pack_241, pack_typed: pack_241_typed, write: |seed, offsets, row| { write_241(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_266, pack: pack_266, pack_typed: pack_266_typed, write: write_266 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 14, selectors: 2, auxiliaries: 4, lookups: 3 }, output_size: 1, seed_words: 17, schema: &SCHEMA_297, pack: pack_297, pack_typed: pack_297_typed, write: |seed, offsets, row| { write_297(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 108, lookups: 6 }, output_size: 1, seed_words: 110, schema: &SCHEMA_300, pack: pack_300, pack_typed: pack_300_typed, write: write_300 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 142, lookups: 7 }, output_size: 1, seed_words: 145, schema: &SCHEMA_301, pack: pack_301, pack_typed: pack_301_typed, write: write_301 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 94, lookups: 3 }, output_size: 45, seed_words: 95, schema: &SCHEMA_303, pack: pack_303, pack_typed: pack_303_typed, write: write_303 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 102, lookups: 6 }, output_size: 1, seed_words: 60, schema: &SCHEMA_305, pack: pack_305, pack_typed: pack_305_typed, write: write_305 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 }, output_size: 1, seed_words: 10, schema: &SCHEMA_352, pack: pack_352, pack_typed: pack_352_typed, write: write_352 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 17, lookups: 14 }, output_size: 1, seed_words: 10, schema: &SCHEMA_357, pack: pack_357, pack_typed: pack_357_typed, write: write_357 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, output_size: 1, seed_words: 6, schema: &SCHEMA_365, pack: pack_365, pack_typed: pack_365_typed, write: |seed, offsets, row| { write_365(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 }, output_size: 1, seed_words: 10, schema: &SCHEMA_366, pack: pack_366, pack_typed: pack_366_typed, write: write_366 }), +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 }, output_size: 1, seed_words: 7, schema: &SCHEMA_373, pack: pack_373, pack_typed: pack_373_typed, write: write_373 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 12, lookups: 9 }, output_size: 1, seed_words: 12, schema: &SCHEMA_374, pack: pack_374, pack_typed: pack_374_typed, write: write_374 }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 3 }, output_size: 1, seed_words: 6, schema: &SCHEMA_380, pack: pack_380, pack_typed: pack_380_typed, write: write_380 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 }, output_size: 1, seed_words: 9, schema: &SCHEMA_382, pack: pack_382, pack_typed: pack_382_typed, write: write_382 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 }, output_size: 1, seed_words: 8, schema: &SCHEMA_383, pack: pack_383, pack_typed: pack_383_typed, write: write_383 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_384, pack: pack_384, pack_typed: pack_384_typed, write: write_384 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 52, lookups: 37 }, output_size: 2, seed_words: 47, schema: &SCHEMA_396, pack: pack_396, pack_typed: pack_396_typed, write: |seed, offsets, row| { write_396(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 24, auxiliaries: 61, lookups: 38 }, output_size: 1, seed_words: 39, schema: &SCHEMA_401, pack: pack_401, pack_typed: pack_401_typed, write: |seed, offsets, row| { write_401(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 8 }, output_size: 1, seed_words: 5, schema: &SCHEMA_451, pack: pack_451, pack_typed: pack_451_typed, write: |seed, offsets, row| { write_451(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 16, lookups: 7 }, output_size: 2, seed_words: 14, schema: &SCHEMA_457, pack: pack_457, pack_typed: pack_457_typed, write: |seed, offsets, row| { write_457(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, output_size: 3, seed_words: 11, schema: &SCHEMA_487, pack: pack_487, pack_typed: pack_487_typed, write: |seed, offsets, row| { write_487(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 21, lookups: 11 }, output_size: 1, seed_words: 22, schema: &SCHEMA_512, pack: pack_512, pack_typed: pack_512_typed, write: write_512 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 19, lookups: 13 }, output_size: 1, seed_words: 14, schema: &SCHEMA_536, pack: pack_536, pack_typed: pack_536_typed, write: |seed, offsets, row| { write_536(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 24, lookups: 6 }, output_size: 1, seed_words: 26, schema: &SCHEMA_564, pack: pack_564, pack_typed: pack_564_typed, write: write_564 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 7, lookups: 5 }, output_size: 2, seed_words: 31, schema: &SCHEMA_572, pack: pack_572, pack_typed: pack_572_typed, write: |seed, offsets, row| { write_572(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 34, lookups: 8 }, output_size: 2, seed_words: 40, schema: &SCHEMA_574, pack: pack_574, pack_typed: pack_574_typed, write: |seed, offsets, row| { write_574(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 6 }, output_size: 1, seed_words: 10, schema: &SCHEMA_584, pack: pack_584, pack_typed: pack_584_typed, write: |seed, offsets, row| { write_584(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 35, lookups: 9 }, output_size: 1, seed_words: 39, schema: &SCHEMA_590, pack: pack_590, pack_typed: pack_590_typed, write: write_590 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, output_size: 1, seed_words: 8, schema: &SCHEMA_608, pack: pack_608, pack_typed: pack_608_typed, write: write_608 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 12, selectors: 4, auxiliaries: 14, lookups: 6 }, output_size: 1, seed_words: 25, schema: &SCHEMA_646, pack: pack_646, pack_typed: pack_646_typed, write: |seed, offsets, row| { write_646(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 11, lookups: 5 }, output_size: 1, seed_words: 13, schema: &SCHEMA_652, pack: pack_652, pack_typed: pack_652_typed, write: write_652 }), +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 121, lookups: 12 }, output_size: 1, seed_words: 120, schema: &SCHEMA_659, pack: pack_659, pack_typed: pack_659_typed, write: |seed, offsets, row| { write_659(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 50, lookups: 3 }, output_size: 1, seed_words: 54, schema: &SCHEMA_660, pack: pack_660, pack_typed: pack_660_typed, write: |seed, offsets, row| { write_660(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 10, lookups: 6 }, output_size: 1, seed_words: 13, schema: &SCHEMA_711, pack: pack_711, pack_typed: pack_711_typed, write: write_711 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 13, selectors: 9, auxiliaries: 20, lookups: 15 }, output_size: 0, seed_words: 33, schema: &SCHEMA_719, pack: pack_719, pack_typed: pack_719_typed, write: write_719 }), +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_727, pack: pack_727, pack_typed: pack_727_typed, write: write_727 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 55, lookups: 6 }, output_size: 0, seed_words: 51, schema: &SCHEMA_728, pack: pack_728, pack_typed: pack_728_typed, write: |seed, offsets, row| { write_728(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 6, lookups: 5 }, output_size: 0, seed_words: 8, schema: &SCHEMA_729, pack: pack_729, pack_typed: pack_729_typed, write: write_729 }), +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, output_size: 6, seed_words: 23, schema: &SCHEMA_736, pack: pack_736, pack_typed: pack_736_typed, write: write_736 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 4, auxiliaries: 6, lookups: 5 }, output_size: 0, seed_words: 21, schema: &SCHEMA_739, pack: pack_739, pack_typed: pack_739_typed, write: write_739 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 4, lookups: 4 }, output_size: 0, seed_words: 17, schema: &SCHEMA_740, pack: pack_740, pack_typed: pack_740_typed, write: write_740 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 32, lookups: 6 }, output_size: 2, seed_words: 40, schema: &SCHEMA_752, pack: pack_752, pack_typed: pack_752_typed, write: |seed, offsets, row| { write_752(seed, offsets, row); Ok(()) } }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 3 }, output_size: 49, seed_words: 52, schema: &SCHEMA_755, pack: pack_755, pack_typed: pack_755_typed, write: |seed, offsets, row| { write_755(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 22, lookups: 5 }, output_size: 1, seed_words: 23, schema: &SCHEMA_762, pack: pack_762, pack_typed: pack_762_typed, write: |seed, offsets, row| { write_762(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 39, lookups: 6 }, output_size: 0, seed_words: 49, schema: &SCHEMA_771, pack: pack_771, pack_typed: pack_771_typed, write: write_771 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 51, lookups: 4 }, output_size: 0, seed_words: 53, schema: &SCHEMA_774, pack: pack_774, pack_typed: pack_774_typed, write: write_774 }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 8, selectors: 6, auxiliaries: 115, lookups: 17 }, output_size: 0, seed_words: 123, schema: &SCHEMA_780, pack: pack_780, pack_typed: pack_780_typed, write: write_780 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_783, pack: pack_783, pack_typed: pack_783_typed, write: write_783 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 27, lookups: 4 }, output_size: 8, seed_words: 28, schema: &SCHEMA_784, pack: pack_784, pack_typed: pack_784_typed, write: write_784 }), +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 22, lookups: 10 }, output_size: 1, seed_words: 22, schema: &SCHEMA_787, pack: pack_787, pack_typed: pack_787_typed, write: write_787 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_789, pack: pack_789, pack_typed: pack_789_typed, write: write_789 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 53, lookups: 4 }, output_size: 8, seed_words: 54, schema: &SCHEMA_791, pack: pack_791, pack_typed: pack_791_typed, write: write_791 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_792, pack: pack_792, pack_typed: pack_792_typed, write: write_792 }), +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 4 }, output_size: 8, seed_words: 29, schema: &SCHEMA_796, pack: pack_796, pack_typed: pack_796_typed, write: write_796 }), +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_801, pack: pack_801, pack_typed: pack_801_typed, write: write_801 }), +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 33, lookups: 11 }, output_size: 6, seed_words: 33, schema: &SCHEMA_807, pack: pack_807, pack_typed: pack_807_typed, write: write_807 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 7, lookups: 3 }, output_size: 6, seed_words: 22, schema: &SCHEMA_808, pack: pack_808, pack_typed: pack_808_typed, write: |seed, offsets, row| { write_808(seed, offsets, row); Ok(()) } }), +None +] }; diff --git a/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs b/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs new file mode 100644 index 000000000..1c8a5477f --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs @@ -0,0 +1,926 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_ixvm_contract() -> *const u8; + fn aiur_trace_ixvm_schema() -> *const u8; + pub(super) fn aiur_trace_ixvm_15(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_24(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_26(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_27(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_30(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_34(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_38(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_40(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_41(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_44(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_47(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_48(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_49(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_50(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_51(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_52(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_55(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_56(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_57(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_62(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_63(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_66(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_67(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_68(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_69(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_70(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_73(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_74(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_80(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_81(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_82(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_84(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_85(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_86(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_88(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_91(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_92(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_95(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_100(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_122(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_125(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_127(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_132(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_140(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_142(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_151(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_152(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_154(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_155(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_230(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_241(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_266(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_297(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_300(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_301(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_303(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_305(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_352(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_357(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_365(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_366(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_373(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_374(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_380(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_382(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_383(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_384(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_396(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_401(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_451(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_457(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_487(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_512(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_536(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_564(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_572(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_574(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_584(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_590(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_608(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_646(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_652(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_659(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_660(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_711(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_719(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_727(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_728(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_729(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_736(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_739(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_740(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_752(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_755(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_762(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_771(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_774(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_780(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_783(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_784(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_787(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_789(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_791(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_792(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_796(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_801(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_807(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_ixvm_808(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([71, 12, 39, 10, 46, 246, 206, 207, 13, 202, 124, 148, 208, 20, 179, 9, 173, 133, 63, 124, 82, 148, 252, 238, 173, 234, 55, 16, 172, 128, 84, 141], aiur_trace_ixvm_contract, aiur_trace_ixvm_schema, &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_15), +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_24), +None, +Some(aiur_trace_ixvm_26), +Some(aiur_trace_ixvm_27), +None, +None, +Some(aiur_trace_ixvm_30), +None, +None, +None, +Some(aiur_trace_ixvm_34), +None, +None, +None, +Some(aiur_trace_ixvm_38), +None, +Some(aiur_trace_ixvm_40), +Some(aiur_trace_ixvm_41), +None, +None, +Some(aiur_trace_ixvm_44), +None, +None, +Some(aiur_trace_ixvm_47), +Some(aiur_trace_ixvm_48), +Some(aiur_trace_ixvm_49), +Some(aiur_trace_ixvm_50), +Some(aiur_trace_ixvm_51), +Some(aiur_trace_ixvm_52), +None, +None, +Some(aiur_trace_ixvm_55), +Some(aiur_trace_ixvm_56), +Some(aiur_trace_ixvm_57), +None, +None, +None, +None, +Some(aiur_trace_ixvm_62), +Some(aiur_trace_ixvm_63), +None, +None, +Some(aiur_trace_ixvm_66), +Some(aiur_trace_ixvm_67), +Some(aiur_trace_ixvm_68), +Some(aiur_trace_ixvm_69), +Some(aiur_trace_ixvm_70), +None, +None, +Some(aiur_trace_ixvm_73), +Some(aiur_trace_ixvm_74), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_80), +Some(aiur_trace_ixvm_81), +Some(aiur_trace_ixvm_82), +None, +Some(aiur_trace_ixvm_84), +Some(aiur_trace_ixvm_85), +Some(aiur_trace_ixvm_86), +None, +Some(aiur_trace_ixvm_88), +None, +None, +Some(aiur_trace_ixvm_91), +Some(aiur_trace_ixvm_92), +None, +None, +Some(aiur_trace_ixvm_95), +None, +None, +None, +None, +Some(aiur_trace_ixvm_100), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_122), +None, +None, +Some(aiur_trace_ixvm_125), +None, +Some(aiur_trace_ixvm_127), +None, +None, +None, +None, +Some(aiur_trace_ixvm_132), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_140), +None, +Some(aiur_trace_ixvm_142), +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_151), +Some(aiur_trace_ixvm_152), +None, +Some(aiur_trace_ixvm_154), +Some(aiur_trace_ixvm_155), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_230), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_241), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_266), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_297), +None, +None, +Some(aiur_trace_ixvm_300), +Some(aiur_trace_ixvm_301), +None, +Some(aiur_trace_ixvm_303), +None, +Some(aiur_trace_ixvm_305), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_352), +None, +None, +None, +None, +Some(aiur_trace_ixvm_357), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_365), +Some(aiur_trace_ixvm_366), +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_373), +Some(aiur_trace_ixvm_374), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_380), +None, +Some(aiur_trace_ixvm_382), +Some(aiur_trace_ixvm_383), +Some(aiur_trace_ixvm_384), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_396), +None, +None, +None, +None, +Some(aiur_trace_ixvm_401), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_451), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_457), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_487), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_512), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_536), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_564), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_572), +None, +Some(aiur_trace_ixvm_574), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_584), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_590), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_608), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_646), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_652), +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_659), +Some(aiur_trace_ixvm_660), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_711), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_719), +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_727), +Some(aiur_trace_ixvm_728), +Some(aiur_trace_ixvm_729), +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_736), +None, +None, +Some(aiur_trace_ixvm_739), +Some(aiur_trace_ixvm_740), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_752), +None, +None, +Some(aiur_trace_ixvm_755), +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_762), +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_771), +None, +None, +Some(aiur_trace_ixvm_774), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_780), +None, +None, +Some(aiur_trace_ixvm_783), +Some(aiur_trace_ixvm_784), +None, +None, +Some(aiur_trace_ixvm_787), +None, +Some(aiur_trace_ixvm_789), +None, +Some(aiur_trace_ixvm_791), +Some(aiur_trace_ixvm_792), +None, +None, +None, +Some(aiur_trace_ixvm_796), +None, +None, +None, +None, +Some(aiur_trace_ixvm_801), +None, +None, +None, +None, +None, +Some(aiur_trace_ixvm_807), +Some(aiur_trace_ixvm_808), +None +], &[3, 67, 68, 3, 0, 6, 9, 0, 0, 0, 0, 0, 0, 0, 17, 17, 9, 9, 9, 0, 0, 0, 71, 40, 170, 137, 13, 194, 5, 146, 158, 0, 0, 0, 162, 79, 13, 12, 12, 11, 23, 22, 15, 3, 5, 7, 10, 53, 53, 53, 58, 59, 59, 67, 3, 35, 28, 32, 26, 17, 8, 4, 55, 31, 16, 81, 33, 33, 60, 41, 62, 13, 22, 49, 52, 48, 13, 13, 13, 63, 5, 15, 14, 14, 14, 13, 22, 31, 25, 3, 7, 7, 9, 31, 31, 35, 21, 37, 34, 99, 24, 33, 24, 0, 0, 0, 2, 19, 0, 33, 62, 2, 15, 2, 16, 42, 57, 44, 13, 22, 49, 68, 48, 0, 91, 9, 23, 44, 4, 17, 45, 4, 16, 26, 6, 14, 5, 0, 17, 0, 5, 19, 63, 5, 13, 16, 5, 5, 6, 14, 17, 17, 17, 33, 33, 33, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 12, 4, 4, 19, 13, 11, 7, 2, 2, 2, 2, 2, 2, 8, 5, 15, 12, 32, 13, 13, 18, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 16, 31, 15, 14, 7, 3, 9, 2, 15, 19, 16, 32, 9, 0, 9, 22, 8, 18, 22, 0, 0, 11, 0, 22, 9, 12, 3, 18, 12, 8, 9, 12, 15, 20, 20, 27, 8, 34, 17, 18, 18, 12, 24, 18, 0, 14, 19, 11, 22, 7, 28, 14, 18, 30, 21, 17, 17, 39, 73, 39, 46, 22, 58, 89, 0, 37, 3, 17, 67, 119, 110, 145, 110, 95, 3, 60, 4, 55, 7, 11, 10, 10, 10, 9, 11, 14, 8, 15, 8, 14, 17, 12, 14, 9, 24, 12, 20, 13, 9, 14, 10, 12, 11, 7, 10, 7, 8, 13, 11, 8, 9, 7, 8, 12, 8, 9, 9, 7, 11, 25, 10, 6, 10, 10, 3, 2, 3, 10, 7, 9, 0, 6, 7, 6, 8, 6, 10, 7, 10, 7, 11, 5, 10, 7, 12, 9, 6, 8, 8, 11, 6, 10, 9, 8, 11, 10, 15, 12, 12, 31, 2, 2, 2, 2, 2, 2, 47, 9, 9, 18, 17, 39, 9, 10, 11, 11, 14, 31, 13, 12, 14, 25, 34, 10, 26, 35, 23, 11, 48, 14, 9, 17, 53, 23, 8, 9, 10, 8, 11, 0, 11, 16, 29, 23, 11, 0, 12, 12, 31, 34, 5, 13, 13, 46, 0, 13, 13, 13, 11, 9, 15, 5, 6, 20, 12, 8, 24, 14, 0, 11, 7, 9, 11, 15, 16, 10, 22, 8, 14, 18, 14, 14, 43, 12, 14, 13, 9, 34, 8, 17, 11, 5, 15, 14, 13, 40, 11, 11, 14, 27, 27, 12, 13, 20, 23, 39, 9, 18, 6, 12, 24, 10, 0, 10, 0, 10, 16, 13, 8, 13, 11, 21, 22, 6, 13, 11, 7, 9, 15, 43, 9, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 14, 8, 19, 8, 16, 22, 15, 17, 18, 31, 18, 32, 23, 3, 3, 1, 1, 1, 5, 2, 82, 10, 9, 10, 12, 12, 6, 9, 26, 32, 12, 14, 21, 15, 20, 13, 31, 62, 40, 48, 23, 17, 15, 0, 13, 16, 9, 0, 10, 10, 7, 9, 36, 10, 39, 11, 7, 7, 52, 51, 62, 13, 20, 4, 6, 6, 23, 2, 2, 9, 15, 8, 8, 10, 12, 18, 20, 15, 5, 11, 11, 10, 8, 0, 8, 17, 10, 8, 11, 12, 22, 36, 25, 10, 9, 11, 26, 13, 63, 72, 20, 11, 16, 8, 11, 32, 53, 50, 51, 17, 25, 16, 10, 7, 0, 71, 13, 14, 11, 11, 15, 0, 81, 120, 54, 89, 13, 16, 13, 7, 14, 15, 8, 10, 0, 7, 8, 16, 10, 0, 7, 19, 5, 8, 8, 28, 53, 57, 31, 24, 32, 36, 42, 26, 13, 55, 88, 23, 23, 33, 7, 32, 9, 8, 21, 36, 6, 10, 32, 10, 8, 8, 6, 18, 16, 13, 21, 28, 34, 15, 6, 9, 13, 33, 15, 25, 8, 16, 41, 54, 54, 7, 51, 8, 52, 63, 6, 8, 12, 77, 23, 9, 66, 21, 17, 18, 37, 34, 83, 40, 6, 12, 5, 5, 5, 5, 40, 14, 57, 52, 71, 14, 75, 66, 85, 75, 23, 2, 6, 6, 6, 4, 18, 68, 69, 49, 4, 84, 53, 4, 100, 112, 104, 5, 123, 9, 8, 8, 28, 9, 21, 22, 4, 8, 6, 54, 7, 13, 111, 65, 29, 89, 5, 14, 8, 7, 8, 7, 15, 9, 8, 33, 22, 42], &[16, 528, 536, 16, 0, 48, 72, 0, 0, 0, 0, 0, 0, 0, 136, 24, 72, 72, 72, 0, 0, 0, 544, 296, 432, 840, 80, 848, 40, 416, 272, 0, 0, 0, 176, 152, 104, 40, 40, 32, 64, 56, 48, 16, 16, 32, 32, 360, 360, 360, 96, 96, 96, 408, 16, 272, 216, 64, 64, 56, 48, 24, 96, 64, 56, 152, 72, 64, 112, 88, 120, 40, 48, 80, 88, 72, 40, 40, 40, 120, 32, 112, 48, 48, 48, 40, 40, 184, 184, 16, 32, 24, 32, 208, 224, 160, 120, 288, 200, 440, 176, 240, 168, 0, 0, 0, 16, 80, 0, 200, 200, 16, 64, 16, 64, 144, 272, 152, 56, 80, 184, 320, 192, 0, 304, 56, 48, 80, 24, 24, 168, 24, 48, 176, 32, 96, 24, 0, 136, 0, 32, 120, 208, 40, 96, 64, 24, 24, 32, 64, 24, 24, 24, 64, 64, 64, 40, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 40, 24, 24, 72, 64, 48, 48, 16, 16, 16, 16, 16, 16, 32, 32, 72, 56, 152, 72, 64, 88, 40, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 48, 160, 72, 80, 32, 24, 48, 16, 88, 88, 80, 184, 56, 0, 32, 96, 40, 88, 160, 0, 0, 40, 0, 64, 48, 56, 24, 80, 56, 48, 40, 56, 64, 80, 80, 120, 48, 144, 96, 80, 96, 64, 128, 96, 0, 72, 88, 64, 168, 48, 200, 80, 112, 136, 144, 128, 128, 136, 240, 280, 336, 104, 416, 456, 0, 280, 24, 112, 272, 440, 400, 512, 400, 336, 24, 200, 24, 200, 24, 72, 48, 40, 48, 48, 56, 80, 40, 64, 56, 64, 80, 64, 80, 48, 120, 72, 88, 48, 48, 56, 48, 40, 48, 40, 56, 32, 48, 80, 72, 48, 40, 48, 56, 80, 48, 56, 48, 48, 64, 160, 56, 32, 64, 56, 16, 16, 16, 40, 32, 32, 0, 32, 40, 32, 40, 32, 56, 40, 48, 40, 64, 32, 64, 40, 72, 40, 32, 32, 40, 56, 32, 56, 48, 48, 56, 56, 88, 72, 64, 200, 16, 16, 16, 16, 16, 16, 240, 48, 48, 88, 88, 104, 56, 56, 64, 64, 72, 176, 80, 72, 64, 136, 184, 64, 152, 200, 136, 72, 280, 88, 64, 104, 192, 144, 56, 40, 32, 32, 64, 0, 64, 96, 192, 136, 64, 0, 64, 72, 200, 192, 40, 104, 104, 304, 0, 80, 72, 88, 56, 40, 72, 24, 24, 96, 56, 40, 136, 48, 0, 56, 24, 32, 40, 64, 48, 40, 104, 32, 56, 96, 56, 40, 248, 72, 40, 64, 40, 216, 32, 80, 56, 24, 64, 64, 104, 256, 56, 56, 64, 160, 160, 56, 104, 104, 144, 224, 56, 128, 40, 64, 160, 56, 0, 72, 0, 64, 88, 88, 56, 80, 80, 120, 120, 32, 64, 72, 40, 40, 96, 248, 56, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 48, 32, 96, 48, 88, 112, 72, 88, 96, 160, 104, 152, 128, 16, 24, 8, 8, 8, 40, 16, 592, 80, 48, 48, 80, 80, 32, 48, 120, 136, 72, 56, 128, 88, 128, 104, 144, 408, 240, 280, 56, 120, 112, 0, 80, 88, 56, 0, 56, 56, 40, 48, 184, 56, 192, 56, 40, 32, 192, 184, 216, 104, 136, 24, 32, 32, 144, 16, 16, 56, 80, 24, 56, 56, 72, 112, 112, 72, 32, 72, 48, 56, 56, 0, 32, 104, 32, 32, 72, 72, 136, 184, 160, 56, 56, 72, 168, 96, 264, 312, 136, 64, 80, 32, 56, 200, 184, 184, 184, 104, 168, 104, 48, 48, 0, 304, 56, 80, 64, 64, 112, 0, 384, 464, 200, 424, 72, 80, 96, 48, 88, 88, 56, 64, 0, 48, 48, 96, 56, 0, 48, 120, 32, 56, 48, 200, 336, 328, 192, 160, 216, 208, 264, 168, 72, 208, 416, 144, 56, 224, 56, 208, 56, 56, 128, 224, 40, 64, 192, 56, 56, 64, 40, 96, 80, 56, 136, 176, 184, 104, 40, 56, 88, 184, 72, 104, 48, 64, 144, 184, 400, 40, 152, 32, 184, 440, 32, 40, 72, 560, 120, 56, 232, 104, 80, 88, 280, 272, 416, 296, 32, 56, 32, 40, 32, 32, 216, 64, 168, 152, 296, 64, 264, 232, 368, 280, 48, 16, 16, 16, 16, 32, 144, 536, 536, 152, 24, 456, 152, 24, 624, 304, 440, 24, 568, 72, 56, 48, 216, 56, 160, 120, 24, 48, 40, 256, 48, 96, 456, 304, 176, 360, 32, 96, 48, 48, 56, 40, 88, 64, 48, 184, 144, 312]) }; diff --git a/crates/aiur/src/trace_codegen/programs/mod.rs b/crates/aiur/src/trace_codegen/programs/mod.rs new file mode 100644 index 000000000..3b39ec7e2 --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/mod.rs @@ -0,0 +1,170 @@ +//! Production kernels selected at code generation time. + +use std::sync::Arc; + +use super::{ + GeneratedProgram, contract, + cuda::{CudaLibrary, RegisteredCudaProgram}, +}; +use crate::bytecode::Toplevel; + +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ixvm; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ixvm_cuda; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod multi_stark; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod multi_stark_cuda; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ix_aggr; +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod ix_aggr_cuda; + +const PROGRAMS: &[(&str, &GeneratedProgram, &CudaLibrary)] = &[ + ("ixvm", &ixvm::PROGRAM, &ixvm_cuda::CUDA), + ("multi-stark", &multi_stark::PROGRAM, &multi_stark_cuda::CUDA), + ("ix-aggr", &ix_aggr::PROGRAM, &ix_aggr_cuda::CUDA), +]; + +pub(crate) fn register( + bytecode: Arc, +) -> Result { + let fingerprint = contract::fingerprint(&bytecode); + let Some(&(name, generated, cuda)) = PROGRAMS + .iter() + .find(|(_, generated, _)| generated.fingerprint == fingerprint) + else { + return Err("no generated CUDA library matches this bytecode; regenerate with ix codegen --trace-bundle and rebuild".into()); + }; + let function_circuits = bytecode.circuits.len(); + let constrained_functions = + bytecode.functions.iter().filter(|f| f.constrained).count(); + let registered = cuda + .register(generated, bytecode) + .map_err(|error| format!("{name}: {error}"))?; + let covered = + (0..function_circuits).filter(|&c| registered.bound().supports(c)).count(); + tracing::info!( + program = name, + generated_functions = + generated.functions.iter().filter(|f| f.is_some()).count(), + constrained_functions, + generated_circuits = covered, + function_circuits, + "registered generated CUDA traces; uncovered circuits use CPU traces" + ); + Ok(registered) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + G, + execute::{IOBuffer, QueryRecord}, + gpu_trace::TraceProvider, + }; + use ::multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; + + #[test] + fn production_registration_and_dispatch_match_oracle() { + let fixture = (crate::trace_codegen::tests::blake3::PROGRAM.expected)(); + let mut io = IOBuffer { data: Default::default(), map: Default::default() }; + let mut input = vec![G::ZERO]; + input.extend((0..128).map(|i| G::from_usize((i * 37 + 19) % 256))); + let (fixture_record, _) = fixture.execute(0, input, &mut io).unwrap(); + for &(name, generated, _) in PROGRAMS { + assert!(!generated.complete); + let top = Arc::new((generated.expected)()); + let selected: Vec<_> = generated + .functions + .iter() + .enumerate() + .filter_map(|(i, f)| f.as_ref().map(|_| i)) + .collect(); + // The selection is whole circuits, so every member of a covered + // circuit is generated and no generated function is left uncovered. + let registered = register(top.clone()).unwrap(); + let covered: Vec<_> = (0..top.circuits.len()) + .filter(|&c| registered.bound().supports(c)) + .collect(); + let mut covered_functions: Vec<_> = + covered.iter().flat_map(|&c| top.circuits[c].members.clone()).collect(); + covered_functions.sort_unstable(); + assert_eq!(covered_functions, selected, "{name}: partial circuit"); + // BLAKE3 is the member whose rows the fixture record supplies. + let function = selected + .iter() + .copied() + .find(|&f| top.functions[f].layout == fixture.functions[0].layout) + .expect("blake3_compress is selected"); + let circuit = top + .circuits + .iter() + .position(|c| c.members.contains(&function)) + .unwrap(); + assert_eq!(top.circuits[circuit].members, [function]); + let mut record = QueryRecord::new(&top); + for (input, result) in fixture_record.function_queries[0].iter() { + record.function_queries[function] + .insert(input, result.output, result.multiplicity) + .unwrap(); + } + let count = record.function_queries[function].len(); + let (source, _) = registered + .bound() + .prepare_trace( + circuit, + &record, + &io, + &[], + (0, 0), + (0, count), + count, + false, + ) + .unwrap(); + let mut expected: Vec<_> = (0..count) + .flat_map(|row| { + top.main_row_for_test(circuit, function, row, &record, &io) + }) + .map(|cell| cell.as_canonical_u64()) + .collect(); + let width = top.circuits[circuit].layout.width(); + let height = count.next_power_of_two(); + expected.resize(height * width, 0); + let raw = source.download_tile(0, height - 1, height + 1); + for (i, &word) in raw.iter().enumerate() { + assert_eq!( + word, + expected[(((height - 1) + i / width) % height) * width + i % width], + "{name}: cell {i}" + ); + } + let uncovered = + (0..top.circuits.len()).find(|&c| !covered.contains(&c)).unwrap(); + let provider = TraceProvider::Generated(registered); + assert!( + provider + .prepare(&top, uncovered, &record, &io, &[], (0, 0), (0, 1), 1, false) + .is_none() + ); + assert!( + provider + .prepare(&top, circuit, &record, &io, &[], (0, 0), (0, 0), 0, false) + .is_none() + ); + let mut stale = (generated.expected)(); + stale.functions[0].entry = !stale.functions[0].entry; + assert!(register(Arc::new(stale)).is_err()); + } + assert!(register(Arc::new(fixture)).is_err()); + } +} diff --git a/crates/aiur/src/trace_codegen/programs/multi_stark.rs b/crates/aiur/src/trace_codegen/programs/multi_stark.rs new file mode 100644 index 000000000..1b05b386d --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/multi_stark.rs @@ -0,0 +1,1627 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_76(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed[2] = v_1.as_canonical_u64(); seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); seed[58] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); seed[97] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed[131] = v_130.as_canonical_u64(); seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed[143] = v_142.as_canonical_u64(); seed[144] = v_143.as_canonical_u64(); seed[145] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed[146] = v_145.as_canonical_u64(); seed[147] = v_146.as_canonical_u64(); seed[148] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed[149] = v_148.as_canonical_u64(); seed[150] = v_149.as_canonical_u64(); seed[151] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed[152] = v_151.as_canonical_u64(); seed[153] = v_152.as_canonical_u64(); seed[154] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed[155] = v_154.as_canonical_u64(); seed[156] = v_155.as_canonical_u64(); seed[157] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed[158] = v_157.as_canonical_u64(); seed[159] = v_158.as_canonical_u64(); seed[160] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed[161] = v_160.as_canonical_u64(); seed[162] = v_161.as_canonical_u64(); seed[163] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed[164] = v_163.as_canonical_u64(); seed[165] = v_164.as_canonical_u64(); seed[166] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed[167] = v_166.as_canonical_u64(); seed[168] = v_167.as_canonical_u64(); seed[169] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed[170] = v_169.as_canonical_u64(); seed[171] = v_170.as_canonical_u64(); seed[172] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed[173] = v_172.as_canonical_u64(); seed[174] = v_173.as_canonical_u64(); seed[175] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed[176] = v_175.as_canonical_u64(); seed[177] = v_176.as_canonical_u64(); seed[178] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed[179] = v_178.as_canonical_u64(); seed[180] = v_179.as_canonical_u64(); seed[181] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed[182] = v_181.as_canonical_u64(); seed[183] = v_182.as_canonical_u64(); seed[184] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed[185] = v_184.as_canonical_u64(); seed[186] = v_185.as_canonical_u64(); seed[187] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed[188] = v_187.as_canonical_u64(); seed[189] = v_188.as_canonical_u64(); seed[190] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed[191] = v_190.as_canonical_u64(); seed[192] = v_191.as_canonical_u64(); seed[193] = v_192.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +fn pack_76_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2, v_3]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(784, v_1); seed.full(8, v_2); seed.u32(532, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_3)?; seed.u8(785, v_4); seed.full(16, v_5); seed.u32(536, v_6); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_6)?; seed.u8(786, v_7); seed.full(24, v_8); seed.u32(540, v_9); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = context.load::<3>(3, v_9)?; seed.u8(787, v_10); seed.full(32, v_11); seed.u32(544, v_12); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = context.load::<3>(4, v_12)?; seed.u8(788, v_13); seed.full(40, v_14); seed.u32(548, v_15); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = context.load::<3>(5, v_15)?; seed.u8(789, v_16); seed.full(48, v_17); seed.u32(552, v_18); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = context.load::<3>(6, v_18)?; seed.u8(790, v_19); seed.full(56, v_20); seed.u32(556, v_21); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = context.load::<3>(7, v_21)?; seed.u8(791, v_22); seed.full(64, v_23); seed.u32(560, v_24); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = context.load::<3>(8, v_24)?; seed.u8(792, v_25); seed.full(72, v_26); seed.u32(564, v_27); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = context.load::<3>(9, v_27)?; seed.u8(793, v_28); seed.full(80, v_29); seed.u32(568, v_30); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = context.load::<3>(10, v_30)?; seed.u8(794, v_31); seed.full(88, v_32); seed.u32(572, v_33); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = context.load::<3>(11, v_33)?; seed.u8(795, v_34); seed.full(96, v_35); seed.u32(576, v_36); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(12, v_36)?; seed.u8(796, v_37); seed.full(104, v_38); seed.u32(580, v_39); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = context.load::<3>(13, v_39)?; seed.u8(797, v_40); seed.full(112, v_41); seed.u32(584, v_42); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = context.load::<3>(14, v_42)?; seed.u8(798, v_43); seed.full(120, v_44); seed.u32(588, v_45); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = context.load::<3>(15, v_45)?; seed.u8(799, v_46); seed.full(128, v_47); seed.u32(592, v_48); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = context.load::<3>(16, v_48)?; seed.u8(800, v_49); seed.full(136, v_50); seed.u32(596, v_51); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = context.load::<3>(17, v_51)?; seed.u8(801, v_52); seed.full(144, v_53); seed.u32(600, v_54); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = context.load::<3>(18, v_54)?; seed.u8(802, v_55); seed.full(152, v_56); seed.u32(604, v_57); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = context.load::<3>(19, v_57)?; seed.u8(803, v_58); seed.full(160, v_59); seed.u32(608, v_60); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = context.load::<3>(20, v_60)?; seed.u8(804, v_61); seed.full(168, v_62); seed.u32(612, v_63); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = context.load::<3>(21, v_63)?; seed.u8(805, v_64); seed.full(176, v_65); seed.u32(616, v_66); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = context.load::<3>(22, v_66)?; seed.u8(806, v_67); seed.full(184, v_68); seed.u32(620, v_69); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = context.load::<3>(23, v_69)?; seed.u8(807, v_70); seed.full(192, v_71); seed.u32(624, v_72); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(24, v_72)?; seed.u8(808, v_73); seed.full(200, v_74); seed.u32(628, v_75); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = context.load::<3>(25, v_75)?; seed.u8(809, v_76); seed.full(208, v_77); seed.u32(632, v_78); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = context.load::<3>(26, v_78)?; seed.u8(810, v_79); seed.full(216, v_80); seed.u32(636, v_81); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = context.load::<3>(27, v_81)?; seed.u8(811, v_82); seed.full(224, v_83); seed.u32(640, v_84); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = context.load::<3>(28, v_84)?; seed.u8(812, v_85); seed.full(232, v_86); seed.u32(644, v_87); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = context.load::<3>(29, v_87)?; seed.u8(813, v_88); seed.full(240, v_89); seed.u32(648, v_90); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = context.load::<3>(30, v_90)?; seed.u8(814, v_91); seed.full(248, v_92); seed.u32(652, v_93); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = context.load::<3>(31, v_93)?; seed.u8(815, v_94); seed.full(256, v_95); seed.u32(656, v_96); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = context.load::<3>(32, v_96)?; seed.u8(816, v_97); seed.full(264, v_98); seed.u32(660, v_99); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = context.load::<3>(33, v_99)?; seed.u8(817, v_100); seed.full(272, v_101); seed.u32(664, v_102); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = context.load::<3>(34, v_102)?; seed.u8(818, v_103); seed.full(280, v_104); seed.u32(668, v_105); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = context.load::<3>(35, v_105)?; seed.u8(819, v_106); seed.full(288, v_107); seed.u32(672, v_108); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = context.load::<3>(36, v_108)?; seed.u8(820, v_109); seed.full(296, v_110); seed.u32(676, v_111); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = context.load::<3>(37, v_111)?; seed.u8(821, v_112); seed.full(304, v_113); seed.u32(680, v_114); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = context.load::<3>(38, v_114)?; seed.u8(822, v_115); seed.full(312, v_116); seed.u32(684, v_117); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = context.load::<3>(39, v_117)?; seed.u8(823, v_118); seed.full(320, v_119); seed.u32(688, v_120); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = context.load::<3>(40, v_120)?; seed.u8(824, v_121); seed.full(328, v_122); seed.u32(692, v_123); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = context.load::<3>(41, v_123)?; seed.u8(825, v_124); seed.full(336, v_125); seed.u32(696, v_126); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = context.load::<3>(42, v_126)?; seed.u8(826, v_127); seed.full(344, v_128); seed.u32(700, v_129); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = context.load::<3>(43, v_129)?; seed.u8(827, v_130); seed.full(352, v_131); seed.u32(704, v_132); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = context.load::<3>(44, v_132)?; seed.u8(828, v_133); seed.full(360, v_134); seed.u32(708, v_135); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = context.load::<3>(45, v_135)?; seed.u8(829, v_136); seed.full(368, v_137); seed.u32(712, v_138); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = context.load::<3>(46, v_138)?; seed.u8(830, v_139); seed.full(376, v_140); seed.u32(716, v_141); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = context.load::<3>(47, v_141)?; seed.u8(831, v_142); seed.full(384, v_143); seed.u32(720, v_144); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = context.load::<3>(48, v_144)?; seed.u8(832, v_145); seed.full(392, v_146); seed.u32(724, v_147); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = context.load::<3>(49, v_147)?; seed.u8(833, v_148); seed.full(400, v_149); seed.u32(728, v_150); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = context.load::<3>(50, v_150)?; seed.u8(834, v_151); seed.full(408, v_152); seed.u32(732, v_153); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = context.load::<3>(51, v_153)?; seed.u8(835, v_154); seed.full(416, v_155); seed.u32(736, v_156); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = context.load::<3>(52, v_156)?; seed.u8(836, v_157); seed.full(424, v_158); seed.u32(740, v_159); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = context.load::<3>(53, v_159)?; seed.u8(837, v_160); seed.full(432, v_161); seed.u32(744, v_162); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = context.load::<3>(54, v_162)?; seed.u8(838, v_163); seed.full(440, v_164); seed.u32(748, v_165); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(55, v_165)?; seed.u8(839, v_166); seed.full(448, v_167); seed.u32(752, v_168); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = context.load::<3>(56, v_168)?; seed.u8(840, v_169); seed.full(456, v_170); seed.u32(756, v_171); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = context.load::<3>(57, v_171)?; seed.u8(841, v_172); seed.full(464, v_173); seed.u32(760, v_174); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = context.load::<3>(58, v_174)?; seed.u8(842, v_175); seed.full(472, v_176); seed.u32(764, v_177); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = context.load::<3>(59, v_177)?; seed.u8(843, v_178); seed.full(480, v_179); seed.u32(768, v_180); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = context.load::<3>(60, v_180)?; seed.u8(844, v_181); seed.full(488, v_182); seed.u32(772, v_183); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = context.load::<3>(61, v_183)?; seed.u8(845, v_184); seed.full(496, v_185); seed.u32(776, v_186); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = context.load::<3>(62, v_186)?; seed.u8(846, v_187); seed.full(504, v_188); seed.u32(780, v_189); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = context.load::<3>(63, v_189)?; seed.u8(847, v_190); seed.full(512, v_191); seed.full(520, v_192); Ok(()) }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +fn write_76(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let [v_1, v_2, v_3]: [G; 3] = [G::from_u64(seed[2]), G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_6.as_canonical_u64(); match v_4.as_canonical_u64() { 0u64 => { let [v_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 0u64 => { let [v_10, v_11, v_12]: [G; 3] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); match v_10.as_canonical_u64() { 0u64 => { let [v_13, v_14, v_15]: [G; 3] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_15.as_canonical_u64(); match v_13.as_canonical_u64() { 0u64 => { let [v_16, v_17, v_18]: [G; 3] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 16] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_18.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21]: [G; 3] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_21.as_canonical_u64(); match v_19.as_canonical_u64() { 0u64 => { let [v_22, v_23, v_24]: [G; 3] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 22] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_24.as_canonical_u64(); match v_22.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27]: [G; 3] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 25] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_27.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_28, v_29, v_30]: [G; 3] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 28] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_30.as_canonical_u64(); match v_28.as_canonical_u64() { 0u64 => { let [v_31, v_32, v_33]: [G; 3] = [G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34])]; row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_33.as_canonical_u64(); match v_31.as_canonical_u64() { 0u64 => { let [v_34, v_35, v_36]: [G; 3] = [G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37])]; row[offsets.auxiliaries + 34] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_36.as_canonical_u64(); match v_34.as_canonical_u64() { 0u64 => { let [v_37, v_38, v_39]: [G; 3] = [G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 37] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 0u64 => { let [v_40, v_41, v_42]: [G; 3] = [G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 40] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_42.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { let [v_43, v_44, v_45]: [G; 3] = [G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 43] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_45.as_canonical_u64(); match v_43.as_canonical_u64() { 0u64 => { let [v_46, v_47, v_48]: [G; 3] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49])]; row[offsets.auxiliaries + 46] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_48.as_canonical_u64(); match v_46.as_canonical_u64() { 0u64 => { let [v_49, v_50, v_51]: [G; 3] = [G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_51.as_canonical_u64(); match v_49.as_canonical_u64() { 0u64 => { let [v_52, v_53, v_54]: [G; 3] = [G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55])]; row[offsets.auxiliaries + 52] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_54.as_canonical_u64(); match v_52.as_canonical_u64() { 0u64 => { let [v_55, v_56, v_57]: [G; 3] = [G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58])]; row[offsets.auxiliaries + 55] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_57.as_canonical_u64(); match v_55.as_canonical_u64() { 0u64 => { let [v_58, v_59, v_60]: [G; 3] = [G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 58] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_60.as_canonical_u64(); match v_58.as_canonical_u64() { 0u64 => { let [v_61, v_62, v_63]: [G; 3] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 61] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_63.as_canonical_u64(); match v_61.as_canonical_u64() { 0u64 => { let [v_64, v_65, v_66]: [G; 3] = [G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67])]; row[offsets.auxiliaries + 64] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_66.as_canonical_u64(); match v_64.as_canonical_u64() { 0u64 => { let [v_67, v_68, v_69]: [G; 3] = [G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 67] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_69.as_canonical_u64(); match v_67.as_canonical_u64() { 0u64 => { let [v_70, v_71, v_72]: [G; 3] = [G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73])]; row[offsets.auxiliaries + 70] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_72.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { let [v_73, v_74, v_75]: [G; 3] = [G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76])]; row[offsets.auxiliaries + 73] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_75.as_canonical_u64(); match v_73.as_canonical_u64() { 0u64 => { let [v_76, v_77, v_78]: [G; 3] = [G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 76] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_78.as_canonical_u64(); match v_76.as_canonical_u64() { 0u64 => { let [v_79, v_80, v_81]: [G; 3] = [G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82])]; row[offsets.auxiliaries + 79] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_81.as_canonical_u64(); match v_79.as_canonical_u64() { 0u64 => { let [v_82, v_83, v_84]: [G; 3] = [G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85])]; row[offsets.auxiliaries + 82] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_84.as_canonical_u64(); match v_82.as_canonical_u64() { 0u64 => { let [v_85, v_86, v_87]: [G; 3] = [G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88])]; row[offsets.auxiliaries + 85] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_87.as_canonical_u64(); match v_85.as_canonical_u64() { 0u64 => { let [v_88, v_89, v_90]: [G; 3] = [G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91])]; row[offsets.auxiliaries + 88] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_90.as_canonical_u64(); match v_88.as_canonical_u64() { 0u64 => { let [v_91, v_92, v_93]: [G; 3] = [G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 91] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_93.as_canonical_u64(); match v_91.as_canonical_u64() { 0u64 => { let [v_94, v_95, v_96]: [G; 3] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 94] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_96.as_canonical_u64(); match v_94.as_canonical_u64() { 0u64 => { let [v_97, v_98, v_99]: [G; 3] = [G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100])]; row[offsets.auxiliaries + 97] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_99.as_canonical_u64(); match v_97.as_canonical_u64() { 0u64 => { let [v_100, v_101, v_102]: [G; 3] = [G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103])]; row[offsets.auxiliaries + 100] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_102.as_canonical_u64(); match v_100.as_canonical_u64() { 0u64 => { let [v_103, v_104, v_105]: [G; 3] = [G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106])]; row[offsets.auxiliaries + 103] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_105.as_canonical_u64(); match v_103.as_canonical_u64() { 0u64 => { let [v_106, v_107, v_108]: [G; 3] = [G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109])]; row[offsets.auxiliaries + 106] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_108.as_canonical_u64(); match v_106.as_canonical_u64() { 0u64 => { let [v_109, v_110, v_111]: [G; 3] = [G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 109] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_111.as_canonical_u64(); match v_109.as_canonical_u64() { 0u64 => { let [v_112, v_113, v_114]: [G; 3] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 112] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_114.as_canonical_u64(); match v_112.as_canonical_u64() { 0u64 => { let [v_115, v_116, v_117]: [G; 3] = [G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118])]; row[offsets.auxiliaries + 115] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_117.as_canonical_u64(); match v_115.as_canonical_u64() { 0u64 => { let [v_118, v_119, v_120]: [G; 3] = [G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121])]; row[offsets.auxiliaries + 118] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_120.as_canonical_u64(); match v_118.as_canonical_u64() { 0u64 => { let [v_121, v_122, v_123]: [G; 3] = [G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124])]; row[offsets.auxiliaries + 121] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_123.as_canonical_u64(); match v_121.as_canonical_u64() { 0u64 => { let [v_124, v_125, v_126]: [G; 3] = [G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127])]; row[offsets.auxiliaries + 124] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_126.as_canonical_u64(); match v_124.as_canonical_u64() { 0u64 => { let [v_127, v_128, v_129]: [G; 3] = [G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130])]; row[offsets.auxiliaries + 127] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_129.as_canonical_u64(); match v_127.as_canonical_u64() { 0u64 => { let [v_130, v_131, v_132]: [G; 3] = [G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133])]; row[offsets.auxiliaries + 130] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_132.as_canonical_u64(); match v_130.as_canonical_u64() { 0u64 => { let [v_133, v_134, v_135]: [G; 3] = [G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136])]; row[offsets.auxiliaries + 133] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_135.as_canonical_u64(); match v_133.as_canonical_u64() { 0u64 => { let [v_136, v_137, v_138]: [G; 3] = [G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139])]; row[offsets.auxiliaries + 136] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_138.as_canonical_u64(); match v_136.as_canonical_u64() { 0u64 => { let [v_139, v_140, v_141]: [G; 3] = [G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142])]; row[offsets.auxiliaries + 139] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_141.as_canonical_u64(); match v_139.as_canonical_u64() { 0u64 => { let [v_142, v_143, v_144]: [G; 3] = [G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 142] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_144.as_canonical_u64(); match v_142.as_canonical_u64() { 0u64 => { let [v_145, v_146, v_147]: [G; 3] = [G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 145] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_147.as_canonical_u64(); match v_145.as_canonical_u64() { 0u64 => { let [v_148, v_149, v_150]: [G; 3] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151])]; row[offsets.auxiliaries + 148] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_150.as_canonical_u64(); match v_148.as_canonical_u64() { 0u64 => { let [v_151, v_152, v_153]: [G; 3] = [G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 151] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_153.as_canonical_u64(); match v_151.as_canonical_u64() { 0u64 => { let [v_154, v_155, v_156]: [G; 3] = [G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157])]; row[offsets.auxiliaries + 154] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_156.as_canonical_u64(); match v_154.as_canonical_u64() { 0u64 => { let [v_157, v_158, v_159]: [G; 3] = [G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160])]; row[offsets.auxiliaries + 157] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_159.as_canonical_u64(); match v_157.as_canonical_u64() { 0u64 => { let [v_160, v_161, v_162]: [G; 3] = [G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163])]; row[offsets.auxiliaries + 160] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_162.as_canonical_u64(); match v_160.as_canonical_u64() { 0u64 => { let [v_163, v_164, v_165]: [G; 3] = [G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166])]; row[offsets.auxiliaries + 163] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_165.as_canonical_u64(); match v_163.as_canonical_u64() { 0u64 => { let [v_166, v_167, v_168]: [G; 3] = [G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169])]; row[offsets.auxiliaries + 166] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_168.as_canonical_u64(); match v_166.as_canonical_u64() { 0u64 => { let [v_169, v_170, v_171]: [G; 3] = [G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172])]; row[offsets.auxiliaries + 169] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_171.as_canonical_u64(); match v_169.as_canonical_u64() { 0u64 => { let [v_172, v_173, v_174]: [G; 3] = [G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175])]; row[offsets.auxiliaries + 172] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_174.as_canonical_u64(); match v_172.as_canonical_u64() { 0u64 => { let [v_175, v_176, v_177]: [G; 3] = [G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178])]; row[offsets.auxiliaries + 175] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_177.as_canonical_u64(); match v_175.as_canonical_u64() { 0u64 => { let [v_178, v_179, v_180]: [G; 3] = [G::from_u64(seed[179]), G::from_u64(seed[180]), G::from_u64(seed[181])]; row[offsets.auxiliaries + 178] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_180.as_canonical_u64(); match v_178.as_canonical_u64() { 0u64 => { let [v_181, v_182, v_183]: [G; 3] = [G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184])]; row[offsets.auxiliaries + 181] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_183.as_canonical_u64(); match v_181.as_canonical_u64() { 0u64 => { let [v_184, v_185, v_186]: [G; 3] = [G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187])]; row[offsets.auxiliaries + 184] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_186.as_canonical_u64(); match v_184.as_canonical_u64() { 0u64 => { let [v_187, v_188, v_189]: [G; 3] = [G::from_u64(seed[188]), G::from_u64(seed[189]), G::from_u64(seed[190])]; row[offsets.auxiliaries + 187] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_189.as_canonical_u64(); match v_187.as_canonical_u64() { 0u64 => { let [v_190, v_191, v_192]: [G; 3] = [G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193])]; row[offsets.auxiliaries + 190] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_192.as_canonical_u64(); match v_190.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_190)) }, } }, _ => { Err(no_match(76, v_187)) }, } }, _ => { Err(no_match(76, v_184)) }, } }, _ => { Err(no_match(76, v_181)) }, } }, _ => { Err(no_match(76, v_178)) }, } }, _ => { Err(no_match(76, v_175)) }, } }, _ => { Err(no_match(76, v_172)) }, } }, _ => { Err(no_match(76, v_169)) }, } }, _ => { Err(no_match(76, v_166)) }, } }, _ => { Err(no_match(76, v_163)) }, } }, _ => { Err(no_match(76, v_160)) }, } }, _ => { Err(no_match(76, v_157)) }, } }, _ => { Err(no_match(76, v_154)) }, } }, _ => { Err(no_match(76, v_151)) }, } }, _ => { Err(no_match(76, v_148)) }, } }, _ => { Err(no_match(76, v_145)) }, } }, _ => { Err(no_match(76, v_142)) }, } }, _ => { Err(no_match(76, v_139)) }, } }, _ => { Err(no_match(76, v_136)) }, } }, _ => { Err(no_match(76, v_133)) }, } }, _ => { Err(no_match(76, v_130)) }, } }, _ => { Err(no_match(76, v_127)) }, } }, _ => { Err(no_match(76, v_124)) }, } }, _ => { Err(no_match(76, v_121)) }, } }, _ => { Err(no_match(76, v_118)) }, } }, _ => { Err(no_match(76, v_115)) }, } }, _ => { Err(no_match(76, v_112)) }, } }, _ => { Err(no_match(76, v_109)) }, } }, _ => { Err(no_match(76, v_106)) }, } }, _ => { Err(no_match(76, v_103)) }, } }, _ => { Err(no_match(76, v_100)) }, } }, _ => { Err(no_match(76, v_97)) }, } }, _ => { Err(no_match(76, v_94)) }, } }, _ => { Err(no_match(76, v_91)) }, } }, _ => { Err(no_match(76, v_88)) }, } }, _ => { Err(no_match(76, v_85)) }, } }, _ => { Err(no_match(76, v_82)) }, } }, _ => { Err(no_match(76, v_79)) }, } }, _ => { Err(no_match(76, v_76)) }, } }, _ => { Err(no_match(76, v_73)) }, } }, _ => { Err(no_match(76, v_70)) }, } }, _ => { Err(no_match(76, v_67)) }, } }, _ => { Err(no_match(76, v_64)) }, } }, _ => { Err(no_match(76, v_61)) }, } }, _ => { Err(no_match(76, v_58)) }, } }, _ => { Err(no_match(76, v_55)) }, } }, _ => { Err(no_match(76, v_52)) }, } }, _ => { Err(no_match(76, v_49)) }, } }, _ => { Err(no_match(76, v_46)) }, } }, _ => { Err(no_match(76, v_43)) }, } }, _ => { Err(no_match(76, v_40)) }, } }, _ => { Err(no_match(76, v_37)) }, } }, _ => { Err(no_match(76, v_34)) }, } }, _ => { Err(no_match(76, v_31)) }, } }, _ => { Err(no_match(76, v_28)) }, } }, _ => { Err(no_match(76, v_25)) }, } }, _ => { Err(no_match(76, v_22)) }, } }, _ => { Err(no_match(76, v_19)) }, } }, _ => { Err(no_match(76, v_16)) }, } }, _ => { Err(no_match(76, v_13)) }, } }, _ => { Err(no_match(76, v_10)) }, } }, _ => { Err(no_match(76, v_7)) }, } }, _ => { Err(no_match(76, v_4)) }, } }, _ => { Err(no_match(76, v_1)) }, } } + +static SCHEMA_76: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 528, 784, 8, 532, 785, 16, 536, 786, 24, 540, 787, 32, 544, 788, 40, 548, 789, 48, 552, 790, 56, 556, 791, 64, 560, 792, 72, 564, 793, 80, 568, 794, 88, 572, 795, 96, 576, 796, 104, 580, 797, 112, 584, 798, 120, 588, 799, 128, 592, 800, 136, 596, 801, 144, 600, 802, 152, 604, 803, 160, 608, 804, 168, 612, 805, 176, 616, 806, 184, 620, 807, 192, 624, 808, 200, 628, 809, 208, 632, 810, 216, 636, 811, 224, 640, 812, 232, 644, 813, 240, 648, 814, 248, 652, 815, 256, 656, 816, 264, 660, 817, 272, 664, 818, 280, 668, 819, 288, 672, 820, 296, 676, 821, 304, 680, 822, 312, 684, 823, 320, 688, 824, 328, 692, 825, 336, 696, 826, 344, 700, 827, 352, 704, 828, 360, 708, 829, 368, 712, 830, 376, 716, 831, 384, 720, 832, 392, 724, 833, 400, 728, 834, 408, 732, 835, 416, 736, 836, 424, 740, 837, 432, 744, 838, 440, 748, 839, 448, 752, 840, 456, 756, 841, 464, 760, 842, 472, 764, 843, 480, 768, 844, 488, 772, 845, 496, 776, 846, 504, 780, 847, 512, 520], bytes: 848 }; + +fn pack_78(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = context.load::<8>(3, v_3)?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_17]: [G; 1] = [v_6 + v_7]; let [v_18]: [G; 1] = [v_8 + v_17]; let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 32] = context.load::<32>(6, v_4)?; seed[15] = v_19.as_canonical_u64(); seed[16] = v_20.as_canonical_u64(); seed[17] = v_21.as_canonical_u64(); seed[18] = v_22.as_canonical_u64(); seed[19] = v_23.as_canonical_u64(); seed[20] = v_24.as_canonical_u64(); seed[21] = v_25.as_canonical_u64(); seed[22] = v_26.as_canonical_u64(); seed[23] = v_27.as_canonical_u64(); seed[24] = v_28.as_canonical_u64(); seed[25] = v_29.as_canonical_u64(); seed[26] = v_30.as_canonical_u64(); seed[27] = v_31.as_canonical_u64(); seed[28] = v_32.as_canonical_u64(); seed[29] = v_33.as_canonical_u64(); seed[30] = v_34.as_canonical_u64(); seed[31] = v_35.as_canonical_u64(); seed[32] = v_36.as_canonical_u64(); seed[33] = v_37.as_canonical_u64(); seed[34] = v_38.as_canonical_u64(); seed[35] = v_39.as_canonical_u64(); seed[36] = v_40.as_canonical_u64(); seed[37] = v_41.as_canonical_u64(); seed[38] = v_42.as_canonical_u64(); seed[39] = v_43.as_canonical_u64(); seed[40] = v_44.as_canonical_u64(); seed[41] = v_45.as_canonical_u64(); seed[42] = v_46.as_canonical_u64(); seed[43] = v_47.as_canonical_u64(); seed[44] = v_48.as_canonical_u64(); seed[45] = v_49.as_canonical_u64(); seed[46] = v_50.as_canonical_u64(); let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.load::<8>(8, v_3)?; seed[47] = v_52.as_canonical_u64(); seed[48] = v_53.as_canonical_u64(); seed[49] = v_54.as_canonical_u64(); seed[50] = v_55.as_canonical_u64(); seed[51] = v_56.as_canonical_u64(); seed[52] = v_57.as_canonical_u64(); seed[53] = v_58.as_canonical_u64(); seed[54] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(103)]; let [v_61]: [G; 1] = [G::from_u64(230)]; let [v_62]: [G; 1] = [G::from_u64(9)]; let [v_63]: [G; 1] = [G::from_u64(106)]; let [v_64]: [G; 1] = [G::from_u64(133)]; let [v_65]: [G; 1] = [G::from_u64(174)]; let [v_66]: [G; 1] = [G::from_u64(187)]; let [v_67]: [G; 1] = [G::from_u64(114)]; let [v_68]: [G; 1] = [G::from_u64(243)]; let [v_69]: [G; 1] = [G::from_u64(110)]; let [v_70]: [G; 1] = [G::from_u64(60)]; let [v_71]: [G; 1] = [G::from_u64(58)]; let [v_72]: [G; 1] = [G::from_u64(245)]; let [v_73]: [G; 1] = [G::from_u64(79)]; let [v_74]: [G; 1] = [G::from_u64(165)]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 32] = context.call::<32>(24, 83, &[v_51, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_60, v_61, v_62, v_63, v_64, v_65, v_60, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_51, v_51, v_51, v_51, v_18, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51])?; seed[55] = v_75.as_canonical_u64(); seed[56] = v_76.as_canonical_u64(); seed[57] = v_77.as_canonical_u64(); seed[58] = v_78.as_canonical_u64(); seed[59] = v_79.as_canonical_u64(); seed[60] = v_80.as_canonical_u64(); seed[61] = v_81.as_canonical_u64(); seed[62] = v_82.as_canonical_u64(); seed[63] = v_83.as_canonical_u64(); seed[64] = v_84.as_canonical_u64(); seed[65] = v_85.as_canonical_u64(); seed[66] = v_86.as_canonical_u64(); seed[67] = v_87.as_canonical_u64(); seed[68] = v_88.as_canonical_u64(); seed[69] = v_89.as_canonical_u64(); seed[70] = v_90.as_canonical_u64(); seed[71] = v_91.as_canonical_u64(); seed[72] = v_92.as_canonical_u64(); seed[73] = v_93.as_canonical_u64(); seed[74] = v_94.as_canonical_u64(); seed[75] = v_95.as_canonical_u64(); seed[76] = v_96.as_canonical_u64(); seed[77] = v_97.as_canonical_u64(); seed[78] = v_98.as_canonical_u64(); seed[79] = v_99.as_canonical_u64(); seed[80] = v_100.as_canonical_u64(); seed[81] = v_101.as_canonical_u64(); seed[82] = v_102.as_canonical_u64(); seed[83] = v_103.as_canonical_u64(); seed[84] = v_104.as_canonical_u64(); seed[85] = v_105.as_canonical_u64(); seed[86] = v_106.as_canonical_u64(); let [v_107]: [G; 1] = context.store(25, &[v_51, v_5, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106])?; seed[87] = v_107.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_108]: [G; 1] = [G::from_u64(0)]; let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = context.load::<32>(27, v_4)?; seed[7] = v_109.as_canonical_u64(); seed[8] = v_110.as_canonical_u64(); seed[9] = v_111.as_canonical_u64(); seed[10] = v_112.as_canonical_u64(); seed[11] = v_113.as_canonical_u64(); seed[12] = v_114.as_canonical_u64(); seed[13] = v_115.as_canonical_u64(); seed[14] = v_116.as_canonical_u64(); seed[15] = v_117.as_canonical_u64(); seed[16] = v_118.as_canonical_u64(); seed[17] = v_119.as_canonical_u64(); seed[18] = v_120.as_canonical_u64(); seed[19] = v_121.as_canonical_u64(); seed[20] = v_122.as_canonical_u64(); seed[21] = v_123.as_canonical_u64(); seed[22] = v_124.as_canonical_u64(); seed[23] = v_125.as_canonical_u64(); seed[24] = v_126.as_canonical_u64(); seed[25] = v_127.as_canonical_u64(); seed[26] = v_128.as_canonical_u64(); seed[27] = v_129.as_canonical_u64(); seed[28] = v_130.as_canonical_u64(); seed[29] = v_131.as_canonical_u64(); seed[30] = v_132.as_canonical_u64(); seed[31] = v_133.as_canonical_u64(); seed[32] = v_134.as_canonical_u64(); seed[33] = v_135.as_canonical_u64(); seed[34] = v_136.as_canonical_u64(); seed[35] = v_137.as_canonical_u64(); seed[36] = v_138.as_canonical_u64(); seed[37] = v_139.as_canonical_u64(); seed[38] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = context.store(28, &[v_108, v_5, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140])?; seed[39] = v_141.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = context.load::<8>(29, v_3)?; seed[7] = v_142.as_canonical_u64(); seed[8] = v_143.as_canonical_u64(); seed[9] = v_144.as_canonical_u64(); seed[10] = v_145.as_canonical_u64(); seed[11] = v_146.as_canonical_u64(); seed[12] = v_147.as_canonical_u64(); seed[13] = v_148.as_canonical_u64(); seed[14] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(30, 2, &[v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149])?; seed[15] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_150 * v_8]; let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; let [v_154]: [G; 1] = [v_153 * v_6]; let [v_155]: [G; 1] = [v_151 + v_154]; let [v_156]: [G; 1] = [v_7 + v_155]; let [v_157]: [G; 1] = [G::from_u64(64)]; let [v_158]: [G; 1] = [v_157 - v_1]; let [v_159]: [G; 1] = context.call::<1>(39, 77, &[v_0, v_158])?; seed[16] = v_159.as_canonical_u64(); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = context.call::<64>(40, 76, &[v_159])?; seed[17] = v_160.as_canonical_u64(); seed[18] = v_161.as_canonical_u64(); seed[19] = v_162.as_canonical_u64(); seed[20] = v_163.as_canonical_u64(); seed[21] = v_164.as_canonical_u64(); seed[22] = v_165.as_canonical_u64(); seed[23] = v_166.as_canonical_u64(); seed[24] = v_167.as_canonical_u64(); seed[25] = v_168.as_canonical_u64(); seed[26] = v_169.as_canonical_u64(); seed[27] = v_170.as_canonical_u64(); seed[28] = v_171.as_canonical_u64(); seed[29] = v_172.as_canonical_u64(); seed[30] = v_173.as_canonical_u64(); seed[31] = v_174.as_canonical_u64(); seed[32] = v_175.as_canonical_u64(); seed[33] = v_176.as_canonical_u64(); seed[34] = v_177.as_canonical_u64(); seed[35] = v_178.as_canonical_u64(); seed[36] = v_179.as_canonical_u64(); seed[37] = v_180.as_canonical_u64(); seed[38] = v_181.as_canonical_u64(); seed[39] = v_182.as_canonical_u64(); seed[40] = v_183.as_canonical_u64(); seed[41] = v_184.as_canonical_u64(); seed[42] = v_185.as_canonical_u64(); seed[43] = v_186.as_canonical_u64(); seed[44] = v_187.as_canonical_u64(); seed[45] = v_188.as_canonical_u64(); seed[46] = v_189.as_canonical_u64(); seed[47] = v_190.as_canonical_u64(); seed[48] = v_191.as_canonical_u64(); seed[49] = v_192.as_canonical_u64(); seed[50] = v_193.as_canonical_u64(); seed[51] = v_194.as_canonical_u64(); seed[52] = v_195.as_canonical_u64(); seed[53] = v_196.as_canonical_u64(); seed[54] = v_197.as_canonical_u64(); seed[55] = v_198.as_canonical_u64(); seed[56] = v_199.as_canonical_u64(); seed[57] = v_200.as_canonical_u64(); seed[58] = v_201.as_canonical_u64(); seed[59] = v_202.as_canonical_u64(); seed[60] = v_203.as_canonical_u64(); seed[61] = v_204.as_canonical_u64(); seed[62] = v_205.as_canonical_u64(); seed[63] = v_206.as_canonical_u64(); seed[64] = v_207.as_canonical_u64(); seed[65] = v_208.as_canonical_u64(); seed[66] = v_209.as_canonical_u64(); seed[67] = v_210.as_canonical_u64(); seed[68] = v_211.as_canonical_u64(); seed[69] = v_212.as_canonical_u64(); seed[70] = v_213.as_canonical_u64(); seed[71] = v_214.as_canonical_u64(); seed[72] = v_215.as_canonical_u64(); seed[73] = v_216.as_canonical_u64(); seed[74] = v_217.as_canonical_u64(); seed[75] = v_218.as_canonical_u64(); seed[76] = v_219.as_canonical_u64(); seed[77] = v_220.as_canonical_u64(); seed[78] = v_221.as_canonical_u64(); seed[79] = v_222.as_canonical_u64(); seed[80] = v_223.as_canonical_u64(); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_224.as_canonical_u64(); seed[82] = v_225.as_canonical_u64(); seed[83] = v_226.as_canonical_u64(); seed[84] = v_227.as_canonical_u64(); seed[85] = v_228.as_canonical_u64(); seed[86] = v_229.as_canonical_u64(); seed[87] = v_230.as_canonical_u64(); seed[88] = v_231.as_canonical_u64(); seed[89] = v_232.as_canonical_u64(); seed[90] = v_233.as_canonical_u64(); seed[91] = v_234.as_canonical_u64(); seed[92] = v_235.as_canonical_u64(); seed[93] = v_236.as_canonical_u64(); seed[94] = v_237.as_canonical_u64(); seed[95] = v_238.as_canonical_u64(); seed[96] = v_239.as_canonical_u64(); seed[97] = v_240.as_canonical_u64(); seed[98] = v_241.as_canonical_u64(); seed[99] = v_242.as_canonical_u64(); seed[100] = v_243.as_canonical_u64(); seed[101] = v_244.as_canonical_u64(); seed[102] = v_245.as_canonical_u64(); seed[103] = v_246.as_canonical_u64(); seed[104] = v_247.as_canonical_u64(); seed[105] = v_248.as_canonical_u64(); seed[106] = v_249.as_canonical_u64(); seed[107] = v_250.as_canonical_u64(); seed[108] = v_251.as_canonical_u64(); seed[109] = v_252.as_canonical_u64(); seed[110] = v_253.as_canonical_u64(); seed[111] = v_254.as_canonical_u64(); seed[112] = v_255.as_canonical_u64(); let [v_256]: [G; 1] = [G::from_u64(103)]; let [v_257]: [G; 1] = [G::from_u64(230)]; let [v_258]: [G; 1] = [G::from_u64(9)]; let [v_259]: [G; 1] = [G::from_u64(106)]; let [v_260]: [G; 1] = [G::from_u64(133)]; let [v_261]: [G; 1] = [G::from_u64(174)]; let [v_262]: [G; 1] = [G::from_u64(187)]; let [v_263]: [G; 1] = [G::from_u64(114)]; let [v_264]: [G; 1] = [G::from_u64(243)]; let [v_265]: [G; 1] = [G::from_u64(110)]; let [v_266]: [G; 1] = [G::from_u64(60)]; let [v_267]: [G; 1] = [G::from_u64(58)]; let [v_268]: [G; 1] = [G::from_u64(245)]; let [v_269]: [G; 1] = [G::from_u64(79)]; let [v_270]: [G; 1] = [G::from_u64(165)]; let [v_271]: [G; 1] = [G::from_u64(0)]; let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = context.call::<32>(58, 83, &[v_271, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_256, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_1, v_271, v_271, v_271, v_156, v_271, v_271, v_271, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223])?; seed[113] = v_272.as_canonical_u64(); seed[114] = v_273.as_canonical_u64(); seed[115] = v_274.as_canonical_u64(); seed[116] = v_275.as_canonical_u64(); seed[117] = v_276.as_canonical_u64(); seed[118] = v_277.as_canonical_u64(); seed[119] = v_278.as_canonical_u64(); seed[120] = v_279.as_canonical_u64(); seed[121] = v_280.as_canonical_u64(); seed[122] = v_281.as_canonical_u64(); seed[123] = v_282.as_canonical_u64(); seed[124] = v_283.as_canonical_u64(); seed[125] = v_284.as_canonical_u64(); seed[126] = v_285.as_canonical_u64(); seed[127] = v_286.as_canonical_u64(); seed[128] = v_287.as_canonical_u64(); seed[129] = v_288.as_canonical_u64(); seed[130] = v_289.as_canonical_u64(); seed[131] = v_290.as_canonical_u64(); seed[132] = v_291.as_canonical_u64(); seed[133] = v_292.as_canonical_u64(); seed[134] = v_293.as_canonical_u64(); seed[135] = v_294.as_canonical_u64(); seed[136] = v_295.as_canonical_u64(); seed[137] = v_296.as_canonical_u64(); seed[138] = v_297.as_canonical_u64(); seed[139] = v_298.as_canonical_u64(); seed[140] = v_299.as_canonical_u64(); seed[141] = v_300.as_canonical_u64(); seed[142] = v_301.as_canonical_u64(); seed[143] = v_302.as_canonical_u64(); seed[144] = v_303.as_canonical_u64(); let [v_304]: [G; 1] = context.store(59, &[v_271, v_5, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303])?; seed[145] = v_304.as_canonical_u64(); Ok(()) }, } } + +fn pack_78_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = context.load::<8>(3, v_3)?; seed.full(32, v_9); seed.full(40, v_10); seed.full(48, v_11); seed.full(56, v_12); seed.full(64, v_13); seed.full(72, v_14); seed.full(80, v_15); seed.full(88, v_16); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_17]: [G; 1] = [v_6 + v_7]; let [v_18]: [G; 1] = [v_8 + v_17]; let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 32] = context.load::<32>(6, v_4)?; seed.full(96, v_19); seed.full(104, v_20); seed.full(112, v_21); seed.full(120, v_22); seed.full(128, v_23); seed.full(136, v_24); seed.full(144, v_25); seed.full(152, v_26); seed.full(160, v_27); seed.full(168, v_28); seed.full(176, v_29); seed.full(184, v_30); seed.full(192, v_31); seed.full(200, v_32); seed.full(208, v_33); seed.full(216, v_34); seed.full(224, v_35); seed.full(232, v_36); seed.full(240, v_37); seed.full(248, v_38); seed.full(256, v_39); seed.full(264, v_40); seed.full(272, v_41); seed.full(280, v_42); seed.u32(296, v_43); seed.u8(309, v_44); seed.u8(310, v_45); seed.u8(311, v_46); seed.u8(312, v_47); seed.u8(313, v_48); seed.u8(314, v_49); seed.u8(315, v_50); let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.load::<8>(8, v_3)?; seed.u8(316, v_52); seed.u8(317, v_53); seed.u8(318, v_54); seed.u8(319, v_55); seed.u8(320, v_56); seed.u8(321, v_57); seed.u8(322, v_58); seed.u8(323, v_59); let [v_60]: [G; 1] = [G::from_u64(103)]; let [v_61]: [G; 1] = [G::from_u64(230)]; let [v_62]: [G; 1] = [G::from_u64(9)]; let [v_63]: [G; 1] = [G::from_u64(106)]; let [v_64]: [G; 1] = [G::from_u64(133)]; let [v_65]: [G; 1] = [G::from_u64(174)]; let [v_66]: [G; 1] = [G::from_u64(187)]; let [v_67]: [G; 1] = [G::from_u64(114)]; let [v_68]: [G; 1] = [G::from_u64(243)]; let [v_69]: [G; 1] = [G::from_u64(110)]; let [v_70]: [G; 1] = [G::from_u64(60)]; let [v_71]: [G; 1] = [G::from_u64(58)]; let [v_72]: [G; 1] = [G::from_u64(245)]; let [v_73]: [G; 1] = [G::from_u64(79)]; let [v_74]: [G; 1] = [G::from_u64(165)]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 32] = context.call::<32>(24, 83, &[v_51, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_60, v_61, v_62, v_63, v_64, v_65, v_60, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_51, v_51, v_51, v_51, v_18, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51, v_51])?; seed.u8(324, v_75); seed.u8(325, v_76); seed.u8(326, v_77); seed.u8(327, v_78); seed.u8(328, v_79); seed.u8(329, v_80); seed.u8(330, v_81); seed.u8(331, v_82); seed.u8(332, v_83); seed.u8(333, v_84); seed.u8(334, v_85); seed.u8(335, v_86); seed.u8(336, v_87); seed.u8(337, v_88); seed.u8(338, v_89); seed.u8(339, v_90); seed.u8(340, v_91); seed.u8(341, v_92); seed.u8(342, v_93); seed.u8(343, v_94); seed.u8(344, v_95); seed.u8(345, v_96); seed.u8(346, v_97); seed.u8(347, v_98); seed.u8(348, v_99); seed.u8(349, v_100); seed.u8(350, v_101); seed.u8(351, v_102); seed.u8(352, v_103); seed.u8(353, v_104); seed.u8(354, v_105); seed.u8(355, v_106); let [v_107]: [G; 1] = context.store(25, &[v_51, v_5, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106])?; seed.u32(300, v_107); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_108]: [G; 1] = [G::from_u64(0)]; let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = context.load::<32>(27, v_4)?; seed.full(32, v_109); seed.full(40, v_110); seed.full(48, v_111); seed.full(56, v_112); seed.full(64, v_113); seed.full(72, v_114); seed.full(80, v_115); seed.full(88, v_116); seed.full(96, v_117); seed.full(104, v_118); seed.full(112, v_119); seed.full(120, v_120); seed.full(128, v_121); seed.full(136, v_122); seed.full(144, v_123); seed.full(152, v_124); seed.full(160, v_125); seed.full(168, v_126); seed.full(176, v_127); seed.full(184, v_128); seed.full(192, v_129); seed.full(200, v_130); seed.full(208, v_131); seed.full(216, v_132); seed.full(224, v_133); seed.full(232, v_134); seed.full(240, v_135); seed.full(248, v_136); seed.full(256, v_137); seed.full(264, v_138); seed.full(272, v_139); seed.full(280, v_140); let [v_141]: [G; 1] = context.store(28, &[v_108, v_5, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140])?; seed.u32(296, v_141); Ok(()) }, } }, _ => { let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = context.load::<8>(29, v_3)?; seed.full(32, v_142); seed.full(40, v_143); seed.full(48, v_144); seed.full(56, v_145); seed.full(64, v_146); seed.full(72, v_147); seed.full(80, v_148); seed.full(88, v_149); let [v_150]: [G; 1] = context.call::<1>(30, 2, &[v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149])?; seed.full(96, v_150); let [v_151]: [G; 1] = [v_150 * v_8]; let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; let [v_154]: [G; 1] = [v_153 * v_6]; let [v_155]: [G; 1] = [v_151 + v_154]; let [v_156]: [G; 1] = [v_7 + v_155]; let [v_157]: [G; 1] = [G::from_u64(64)]; let [v_158]: [G; 1] = [v_157 - v_1]; let [v_159]: [G; 1] = context.call::<1>(39, 77, &[v_0, v_158])?; seed.full(104, v_159); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = context.call::<64>(40, 76, &[v_159])?; seed.full(112, v_160); seed.full(120, v_161); seed.full(128, v_162); seed.full(136, v_163); seed.full(144, v_164); seed.full(152, v_165); seed.full(160, v_166); seed.full(168, v_167); seed.full(176, v_168); seed.full(184, v_169); seed.full(192, v_170); seed.full(200, v_171); seed.full(208, v_172); seed.full(216, v_173); seed.full(224, v_174); seed.full(232, v_175); seed.full(240, v_176); seed.full(248, v_177); seed.full(256, v_178); seed.full(264, v_179); seed.full(272, v_180); seed.full(280, v_181); seed.u32(296, v_182); seed.u8(309, v_183); seed.u8(310, v_184); seed.u8(311, v_185); seed.u8(312, v_186); seed.u8(313, v_187); seed.u8(314, v_188); seed.u8(315, v_189); seed.u8(316, v_190); seed.u8(317, v_191); seed.u8(318, v_192); seed.u8(319, v_193); seed.u8(320, v_194); seed.u8(321, v_195); seed.u8(322, v_196); seed.u8(323, v_197); seed.u8(324, v_198); seed.u8(325, v_199); seed.u8(326, v_200); seed.u8(327, v_201); seed.u8(328, v_202); seed.u8(329, v_203); seed.u8(330, v_204); seed.u8(331, v_205); seed.u8(332, v_206); seed.u8(333, v_207); seed.u8(334, v_208); seed.u8(335, v_209); seed.u8(336, v_210); seed.u8(337, v_211); seed.u8(338, v_212); seed.u8(339, v_213); seed.u8(340, v_214); seed.u8(341, v_215); seed.u8(342, v_216); seed.u8(343, v_217); seed.u8(344, v_218); seed.u8(345, v_219); seed.u8(346, v_220); seed.u8(347, v_221); seed.u8(348, v_222); seed.u8(349, v_223); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = context.load::<32>(41, v_4)?; seed.u8(350, v_224); seed.u8(351, v_225); seed.u8(352, v_226); seed.u8(353, v_227); seed.u8(354, v_228); seed.u8(355, v_229); seed.u32(300, v_230); seed.u8(356, v_231); seed.u8(357, v_232); seed.u8(358, v_233); seed.u8(359, v_234); seed.u8(360, v_235); seed.u8(361, v_236); seed.u8(362, v_237); seed.u8(363, v_238); seed.u8(364, v_239); seed.u8(365, v_240); seed.u8(366, v_241); seed.u8(367, v_242); seed.u8(368, v_243); seed.u8(369, v_244); seed.u8(370, v_245); seed.u8(371, v_246); seed.u8(372, v_247); seed.u8(373, v_248); seed.u8(374, v_249); seed.u8(375, v_250); seed.u8(376, v_251); seed.u8(377, v_252); seed.u8(378, v_253); seed.u8(379, v_254); seed.u8(380, v_255); let [v_256]: [G; 1] = [G::from_u64(103)]; let [v_257]: [G; 1] = [G::from_u64(230)]; let [v_258]: [G; 1] = [G::from_u64(9)]; let [v_259]: [G; 1] = [G::from_u64(106)]; let [v_260]: [G; 1] = [G::from_u64(133)]; let [v_261]: [G; 1] = [G::from_u64(174)]; let [v_262]: [G; 1] = [G::from_u64(187)]; let [v_263]: [G; 1] = [G::from_u64(114)]; let [v_264]: [G; 1] = [G::from_u64(243)]; let [v_265]: [G; 1] = [G::from_u64(110)]; let [v_266]: [G; 1] = [G::from_u64(60)]; let [v_267]: [G; 1] = [G::from_u64(58)]; let [v_268]: [G; 1] = [G::from_u64(245)]; let [v_269]: [G; 1] = [G::from_u64(79)]; let [v_270]: [G; 1] = [G::from_u64(165)]; let [v_271]: [G; 1] = [G::from_u64(0)]; let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = context.call::<32>(58, 83, &[v_271, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_256, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_1, v_271, v_271, v_271, v_156, v_271, v_271, v_271, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223])?; seed.u8(381, v_272); seed.u8(382, v_273); seed.u8(383, v_274); seed.u8(384, v_275); seed.u8(385, v_276); seed.u8(386, v_277); seed.u8(387, v_278); seed.u8(388, v_279); seed.u8(389, v_280); seed.u8(390, v_281); seed.u8(391, v_282); seed.u8(392, v_283); seed.u8(393, v_284); seed.u8(394, v_285); seed.u8(395, v_286); seed.u8(396, v_287); seed.u8(397, v_288); seed.u8(398, v_289); seed.u8(399, v_290); seed.u8(400, v_291); seed.u8(401, v_292); seed.u8(402, v_293); seed.u8(403, v_294); seed.u8(404, v_295); seed.u8(405, v_296); seed.u8(406, v_297); seed.u8(407, v_298); seed.u8(408, v_299); seed.u8(409, v_300); seed.u8(410, v_301); seed.u8(411, v_302); seed.u8(412, v_303); let [v_304]: [G; 1] = context.store(59, &[v_271, v_5, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303])?; seed.u32(304, v_304); Ok(()) }, } } + +fn write_78(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); match v_1.as_canonical_u64() { 0u64 => { match v_2.as_canonical_u64() { 0u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 8] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { match v_10.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { 0u64 => { match v_12.as_canonical_u64() { 0u64 => { match v_13.as_canonical_u64() { 0u64 => { match v_14.as_canonical_u64() { 0u64 => { match v_15.as_canonical_u64() { 0u64 => { match v_16.as_canonical_u64() { 0u64 => { let [v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 32] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 9] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_50.as_canonical_u64(); let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = [G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 41] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_59.as_canonical_u64(); let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 32] = [G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86])]; row[offsets.auxiliaries + 49] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_106.as_canonical_u64(); let [v_107]: [G; 1] = [G::from_u64(seed[87])]; row[offsets.auxiliaries + 81] = v_107.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 9] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_14 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_13 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_12 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_11 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_10 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_9 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 1] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140]: [G; 32] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38])]; row[offsets.auxiliaries + 2] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 34] = v_141.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 2] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 10] = v_150.as_canonical_u64(); let [v_152]: [G; 1] = [v_2 - v_1]; let [v_153]: [G; 1] = [G::from_bool(v_152.is_zero())]; row[offsets.auxiliaries + 11] = g_inverse_value(v_152).as_canonical_u64(); row[offsets.auxiliaries + 12] = v_153.as_canonical_u64(); let [v_159]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_159.as_canonical_u64(); let [v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193, v_194, v_195, v_196, v_197, v_198, v_199, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223]: [G; 64] = [G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 14] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_193.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_198.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_199.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_213.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_215.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_223.as_canonical_u64(); let [v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255]: [G; 32] = [G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 78] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_255.as_canonical_u64(); let [v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303]: [G; 32] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144])]; row[offsets.auxiliaries + 110] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_273.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_277.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_279.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_281.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_283.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_284.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_285.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_286.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_287.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_297.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_298.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_299.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_300.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_303.as_canonical_u64(); let [v_304]: [G; 1] = [G::from_u64(seed[145])]; row[offsets.auxiliaries + 142] = v_304.as_canonical_u64(); row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_78: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 8, 308, 16, 288, 292, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 296, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 300, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 304], bytes: 416 }; + +fn pack_79(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 64] = context.call::<64>(3, 76, &[v_1])?; seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); seed[47] = v_49.as_canonical_u64(); seed[48] = v_50.as_canonical_u64(); seed[49] = v_51.as_canonical_u64(); seed[50] = v_52.as_canonical_u64(); seed[51] = v_53.as_canonical_u64(); seed[52] = v_54.as_canonical_u64(); seed[53] = v_55.as_canonical_u64(); seed[54] = v_56.as_canonical_u64(); seed[55] = v_57.as_canonical_u64(); seed[56] = v_58.as_canonical_u64(); seed[57] = v_59.as_canonical_u64(); seed[58] = v_60.as_canonical_u64(); seed[59] = v_61.as_canonical_u64(); seed[60] = v_62.as_canonical_u64(); seed[61] = v_63.as_canonical_u64(); seed[62] = v_64.as_canonical_u64(); seed[63] = v_65.as_canonical_u64(); seed[64] = v_66.as_canonical_u64(); seed[65] = v_67.as_canonical_u64(); seed[66] = v_68.as_canonical_u64(); seed[67] = v_69.as_canonical_u64(); seed[68] = v_70.as_canonical_u64(); seed[69] = v_71.as_canonical_u64(); seed[70] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 249, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed[72] = v_74.as_canonical_u64(); seed[73] = v_75.as_canonical_u64(); seed[74] = v_76.as_canonical_u64(); seed[75] = v_77.as_canonical_u64(); seed[76] = v_78.as_canonical_u64(); seed[77] = v_79.as_canonical_u64(); seed[78] = v_80.as_canonical_u64(); seed[79] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(6, 2, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[80] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed[81] = v_117.as_canonical_u64(); seed[82] = v_118.as_canonical_u64(); seed[83] = v_119.as_canonical_u64(); seed[84] = v_120.as_canonical_u64(); seed[85] = v_121.as_canonical_u64(); seed[86] = v_122.as_canonical_u64(); seed[87] = v_123.as_canonical_u64(); seed[88] = v_124.as_canonical_u64(); seed[89] = v_125.as_canonical_u64(); seed[90] = v_126.as_canonical_u64(); seed[91] = v_127.as_canonical_u64(); seed[92] = v_128.as_canonical_u64(); seed[93] = v_129.as_canonical_u64(); seed[94] = v_130.as_canonical_u64(); seed[95] = v_131.as_canonical_u64(); seed[96] = v_132.as_canonical_u64(); seed[97] = v_133.as_canonical_u64(); seed[98] = v_134.as_canonical_u64(); seed[99] = v_135.as_canonical_u64(); seed[100] = v_136.as_canonical_u64(); seed[101] = v_137.as_canonical_u64(); seed[102] = v_138.as_canonical_u64(); seed[103] = v_139.as_canonical_u64(); seed[104] = v_140.as_canonical_u64(); seed[105] = v_141.as_canonical_u64(); seed[106] = v_142.as_canonical_u64(); seed[107] = v_143.as_canonical_u64(); seed[108] = v_144.as_canonical_u64(); seed[109] = v_145.as_canonical_u64(); seed[110] = v_146.as_canonical_u64(); seed[111] = v_147.as_canonical_u64(); seed[112] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 83, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[113] = v_151.as_canonical_u64(); seed[114] = v_152.as_canonical_u64(); seed[115] = v_153.as_canonical_u64(); seed[116] = v_154.as_canonical_u64(); seed[117] = v_155.as_canonical_u64(); seed[118] = v_156.as_canonical_u64(); seed[119] = v_157.as_canonical_u64(); seed[120] = v_158.as_canonical_u64(); seed[121] = v_159.as_canonical_u64(); seed[122] = v_160.as_canonical_u64(); seed[123] = v_161.as_canonical_u64(); seed[124] = v_162.as_canonical_u64(); seed[125] = v_163.as_canonical_u64(); seed[126] = v_164.as_canonical_u64(); seed[127] = v_165.as_canonical_u64(); seed[128] = v_166.as_canonical_u64(); seed[129] = v_167.as_canonical_u64(); seed[130] = v_168.as_canonical_u64(); seed[131] = v_169.as_canonical_u64(); seed[132] = v_170.as_canonical_u64(); seed[133] = v_171.as_canonical_u64(); seed[134] = v_172.as_canonical_u64(); seed[135] = v_173.as_canonical_u64(); seed[136] = v_174.as_canonical_u64(); seed[137] = v_175.as_canonical_u64(); seed[138] = v_176.as_canonical_u64(); seed[139] = v_177.as_canonical_u64(); seed[140] = v_178.as_canonical_u64(); seed[141] = v_179.as_canonical_u64(); seed[142] = v_180.as_canonical_u64(); seed[143] = v_181.as_canonical_u64(); seed[144] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed[145] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed[146] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 11, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed[147] = v_186.as_canonical_u64(); seed[148] = v_187.as_canonical_u64(); seed[149] = v_188.as_canonical_u64(); seed[150] = v_189.as_canonical_u64(); seed[151] = v_190.as_canonical_u64(); seed[152] = v_191.as_canonical_u64(); seed[153] = v_192.as_canonical_u64(); seed[154] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed[155] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116])?; seed[156] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed[157] = v_196.as_canonical_u64(); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 249, &[v_0])?; seed[71] = v_197.as_canonical_u64(); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 249, &[v_0])?; seed[72] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed[73] = v_200.as_canonical_u64(); seed[74] = v_201.as_canonical_u64(); seed[75] = v_202.as_canonical_u64(); seed[76] = v_203.as_canonical_u64(); seed[77] = v_204.as_canonical_u64(); seed[78] = v_205.as_canonical_u64(); seed[79] = v_206.as_canonical_u64(); seed[80] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = context.call::<1>(56, 2, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed[81] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed[82] = v_217.as_canonical_u64(); seed[83] = v_218.as_canonical_u64(); seed[84] = v_219.as_canonical_u64(); seed[85] = v_220.as_canonical_u64(); seed[86] = v_221.as_canonical_u64(); seed[87] = v_222.as_canonical_u64(); seed[88] = v_223.as_canonical_u64(); seed[89] = v_224.as_canonical_u64(); seed[90] = v_225.as_canonical_u64(); seed[91] = v_226.as_canonical_u64(); seed[92] = v_227.as_canonical_u64(); seed[93] = v_228.as_canonical_u64(); seed[94] = v_229.as_canonical_u64(); seed[95] = v_230.as_canonical_u64(); seed[96] = v_231.as_canonical_u64(); seed[97] = v_232.as_canonical_u64(); seed[98] = v_233.as_canonical_u64(); seed[99] = v_234.as_canonical_u64(); seed[100] = v_235.as_canonical_u64(); seed[101] = v_236.as_canonical_u64(); seed[102] = v_237.as_canonical_u64(); seed[103] = v_238.as_canonical_u64(); seed[104] = v_239.as_canonical_u64(); seed[105] = v_240.as_canonical_u64(); seed[106] = v_241.as_canonical_u64(); seed[107] = v_242.as_canonical_u64(); seed[108] = v_243.as_canonical_u64(); seed[109] = v_244.as_canonical_u64(); seed[110] = v_245.as_canonical_u64(); seed[111] = v_246.as_canonical_u64(); seed[112] = v_247.as_canonical_u64(); seed[113] = v_248.as_canonical_u64(); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 83, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed[114] = v_266.as_canonical_u64(); seed[115] = v_267.as_canonical_u64(); seed[116] = v_268.as_canonical_u64(); seed[117] = v_269.as_canonical_u64(); seed[118] = v_270.as_canonical_u64(); seed[119] = v_271.as_canonical_u64(); seed[120] = v_272.as_canonical_u64(); seed[121] = v_273.as_canonical_u64(); seed[122] = v_274.as_canonical_u64(); seed[123] = v_275.as_canonical_u64(); seed[124] = v_276.as_canonical_u64(); seed[125] = v_277.as_canonical_u64(); seed[126] = v_278.as_canonical_u64(); seed[127] = v_279.as_canonical_u64(); seed[128] = v_280.as_canonical_u64(); seed[129] = v_281.as_canonical_u64(); seed[130] = v_282.as_canonical_u64(); seed[131] = v_283.as_canonical_u64(); seed[132] = v_284.as_canonical_u64(); seed[133] = v_285.as_canonical_u64(); seed[134] = v_286.as_canonical_u64(); seed[135] = v_287.as_canonical_u64(); seed[136] = v_288.as_canonical_u64(); seed[137] = v_289.as_canonical_u64(); seed[138] = v_290.as_canonical_u64(); seed[139] = v_291.as_canonical_u64(); seed[140] = v_292.as_canonical_u64(); seed[141] = v_293.as_canonical_u64(); seed[142] = v_294.as_canonical_u64(); seed[143] = v_295.as_canonical_u64(); seed[144] = v_296.as_canonical_u64(); seed[145] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed[146] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed[147] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed[148] = v_302.as_canonical_u64(); Ok(()) }, } } + +fn pack_79_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6]: [G; 1] = [G::from_u64(1)]; let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 64] = context.call::<64>(3, 76, &[v_1])?; seed.u8(128, v_9); seed.u8(129, v_10); seed.u8(130, v_11); seed.u8(131, v_12); seed.u8(132, v_13); seed.u8(133, v_14); seed.u8(134, v_15); seed.u8(135, v_16); seed.u8(136, v_17); seed.u8(137, v_18); seed.u8(138, v_19); seed.u8(139, v_20); seed.u8(140, v_21); seed.u8(141, v_22); seed.u8(142, v_23); seed.u8(143, v_24); seed.u8(144, v_25); seed.u8(145, v_26); seed.u8(146, v_27); seed.u8(147, v_28); seed.u8(148, v_29); seed.u8(149, v_30); seed.u8(150, v_31); seed.u8(151, v_32); seed.u8(152, v_33); seed.u8(153, v_34); seed.u8(154, v_35); seed.u8(155, v_36); seed.u8(156, v_37); seed.u8(157, v_38); seed.u8(158, v_39); seed.u8(159, v_40); seed.u8(160, v_41); seed.u8(161, v_42); seed.u8(162, v_43); seed.u8(163, v_44); seed.u8(164, v_45); seed.u8(165, v_46); seed.u8(166, v_47); seed.u8(167, v_48); seed.u8(168, v_49); seed.u8(169, v_50); seed.u8(170, v_51); seed.u8(171, v_52); seed.u8(172, v_53); seed.u8(173, v_54); seed.u8(174, v_55); seed.u8(175, v_56); seed.u8(176, v_57); seed.u8(177, v_58); seed.u8(178, v_59); seed.u8(179, v_60); seed.u8(180, v_61); seed.u8(181, v_62); seed.u8(182, v_63); seed.u8(183, v_64); seed.u8(184, v_65); seed.u8(185, v_66); seed.u8(186, v_67); seed.u8(187, v_68); seed.u8(188, v_69); seed.u8(189, v_70); seed.u8(190, v_71); seed.u8(191, v_72); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = context.call::<1>(4, 249, &[v_0])?; seed.u8(192, v_73); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = context.load::<8>(5, v_3)?; seed.u8(193, v_74); seed.u8(194, v_75); seed.u8(195, v_76); seed.u8(196, v_77); seed.u8(197, v_78); seed.u8(198, v_79); seed.u8(199, v_80); seed.u8(200, v_81); let [v_82]: [G; 1] = context.call::<1>(6, 2, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.u8(201, v_82); let [v_83]: [G; 1] = [v_73 * v_82]; let [v_84]: [G; 1] = [v_8 * v_83]; let [v_85]: [G; 1] = [v_84 + v_7]; let [v_86]: [G; 1] = [G::from_u64(103)]; let [v_87]: [G; 1] = [G::from_u64(230)]; let [v_88]: [G; 1] = [G::from_u64(9)]; let [v_89]: [G; 1] = [G::from_u64(106)]; let [v_90]: [G; 1] = [G::from_u64(133)]; let [v_91]: [G; 1] = [G::from_u64(174)]; let [v_92]: [G; 1] = [G::from_u64(187)]; let [v_93]: [G; 1] = [G::from_u64(114)]; let [v_94]: [G; 1] = [G::from_u64(243)]; let [v_95]: [G; 1] = [G::from_u64(110)]; let [v_96]: [G; 1] = [G::from_u64(60)]; let [v_97]: [G; 1] = [G::from_u64(58)]; let [v_98]: [G; 1] = [G::from_u64(245)]; let [v_99]: [G; 1] = [G::from_u64(79)]; let [v_100]: [G; 1] = [G::from_u64(165)]; let [v_101]: [G; 1] = [G::from_u64(127)]; let [v_102]: [G; 1] = [G::from_u64(82)]; let [v_103]: [G; 1] = [G::from_u64(14)]; let [v_104]: [G; 1] = [G::from_u64(81)]; let [v_105]: [G; 1] = [G::from_u64(140)]; let [v_106]: [G; 1] = [G::from_u64(104)]; let [v_107]: [G; 1] = [G::from_u64(5)]; let [v_108]: [G; 1] = [G::from_u64(155)]; let [v_109]: [G; 1] = [G::from_u64(171)]; let [v_110]: [G; 1] = [G::from_u64(217)]; let [v_111]: [G; 1] = [G::from_u64(131)]; let [v_112]: [G; 1] = [G::from_u64(31)]; let [v_113]: [G; 1] = [G::from_u64(25)]; let [v_114]: [G; 1] = [G::from_u64(205)]; let [v_115]: [G; 1] = [G::from_u64(224)]; let [v_116]: [G; 1] = [G::from_u64(91)]; let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = context.load::<32>(41, v_4)?; seed.u8(202, v_117); seed.u8(203, v_118); seed.u8(204, v_119); seed.u8(205, v_120); seed.u8(206, v_121); seed.u8(207, v_122); seed.u8(208, v_123); seed.u8(209, v_124); seed.u8(210, v_125); seed.u8(211, v_126); seed.u8(212, v_127); seed.u8(213, v_128); seed.u8(214, v_129); seed.u8(215, v_130); seed.u8(216, v_131); seed.u8(217, v_132); seed.u8(218, v_133); seed.u8(219, v_134); seed.u8(220, v_135); seed.u8(221, v_136); seed.u8(222, v_137); seed.u8(223, v_138); seed.u8(224, v_139); seed.u8(225, v_140); seed.u8(226, v_141); seed.u8(227, v_142); seed.u8(228, v_143); seed.u8(229, v_144); seed.u8(230, v_145); seed.u8(231, v_146); seed.u8(232, v_147); seed.u8(233, v_148); let [v_149]: [G; 1] = [G::from_u64(64)]; let [v_150]: [G; 1] = [G::from_u64(0)]; let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = context.call::<32>(44, 83, &[v_150, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_149, v_150, v_150, v_150, v_85, v_150, v_150, v_150, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed.u8(234, v_151); seed.u8(235, v_152); seed.u8(236, v_153); seed.u8(237, v_154); seed.u8(238, v_155); seed.u8(239, v_156); seed.u8(240, v_157); seed.u8(241, v_158); seed.u8(242, v_159); seed.u8(243, v_160); seed.u8(244, v_161); seed.u8(245, v_162); seed.u8(246, v_163); seed.u8(247, v_164); seed.u8(248, v_165); seed.u8(249, v_166); seed.u8(250, v_167); seed.u8(251, v_168); seed.u8(252, v_169); seed.u8(253, v_170); seed.u8(254, v_171); seed.u8(255, v_172); seed.u8(256, v_173); seed.u8(257, v_174); seed.u8(258, v_175); seed.u8(259, v_176); seed.u8(260, v_177); seed.u8(261, v_178); seed.u8(262, v_179); seed.u8(263, v_180); seed.u8(264, v_181); seed.u8(265, v_182); let [v_183]: [G; 1] = context.store(45, &[v_150, v_5, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182])?; seed.u32(112, v_183); let [v_184]: [G; 1] = [G::from_u64(1)]; let [v_185]: [G; 1] = context.store(47, &[v_184, v_184, v_184])?; seed.u32(116, v_185); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = context.call::<8>(48, 11, &[v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81])?; seed.full(24, v_186); seed.full(32, v_187); seed.full(40, v_188); seed.full(48, v_189); seed.full(56, v_190); seed.full(64, v_191); seed.full(72, v_192); seed.full(80, v_193); let [v_194]: [G; 1] = context.store(49, &[v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193])?; seed.u32(120, v_194); let [v_195]: [G; 1] = context.store(50, &[v_86, v_87, v_88, v_89, v_90, v_91, v_86, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116])?; seed.u32(124, v_195); let [v_196]: [G; 1] = context.returned::<1>(51)?; seed.full(88, v_196); Ok(()) }, _ => { let [v_197]: [G; 1] = context.call::<1>(52, 249, &[v_0])?; seed.u8(192, v_197); let [v_198]: [G; 1] = [v_197 * v_7]; let [v_199]: [G; 1] = context.call::<1>(54, 249, &[v_0])?; seed.u8(193, v_199); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = context.load::<8>(55, v_3)?; seed.u8(194, v_200); seed.u8(195, v_201); seed.u8(196, v_202); seed.u8(197, v_203); seed.u8(198, v_204); seed.u8(199, v_205); seed.u8(200, v_206); seed.u8(201, v_207); let [v_208]: [G; 1] = context.call::<1>(56, 2, &[v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207])?; seed.u8(202, v_208); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; let [v_214]: [G; 1] = [v_213 * v_6]; let [v_215]: [G; 1] = [v_210 + v_214]; let [v_216]: [G; 1] = [v_198 + v_215]; let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = context.load::<32>(65, v_4)?; seed.u8(203, v_217); seed.u8(204, v_218); seed.u8(205, v_219); seed.u8(206, v_220); seed.u8(207, v_221); seed.u8(208, v_222); seed.u8(209, v_223); seed.u8(210, v_224); seed.u8(211, v_225); seed.u8(212, v_226); seed.u8(213, v_227); seed.u8(214, v_228); seed.u8(215, v_229); seed.u8(216, v_230); seed.u8(217, v_231); seed.u8(218, v_232); seed.u8(219, v_233); seed.u8(220, v_234); seed.u8(221, v_235); seed.u8(222, v_236); seed.u8(223, v_237); seed.u8(224, v_238); seed.u8(225, v_239); seed.u8(226, v_240); seed.u8(227, v_241); seed.u8(228, v_242); seed.u8(229, v_243); seed.u8(230, v_244); seed.u8(231, v_245); seed.u8(232, v_246); seed.u8(233, v_247); seed.u8(234, v_248); let [v_249]: [G; 1] = [G::from_u64(64)]; let [v_250]: [G; 1] = [G::from_u64(103)]; let [v_251]: [G; 1] = [G::from_u64(230)]; let [v_252]: [G; 1] = [G::from_u64(9)]; let [v_253]: [G; 1] = [G::from_u64(106)]; let [v_254]: [G; 1] = [G::from_u64(133)]; let [v_255]: [G; 1] = [G::from_u64(174)]; let [v_256]: [G; 1] = [G::from_u64(187)]; let [v_257]: [G; 1] = [G::from_u64(114)]; let [v_258]: [G; 1] = [G::from_u64(243)]; let [v_259]: [G; 1] = [G::from_u64(110)]; let [v_260]: [G; 1] = [G::from_u64(60)]; let [v_261]: [G; 1] = [G::from_u64(58)]; let [v_262]: [G; 1] = [G::from_u64(245)]; let [v_263]: [G; 1] = [G::from_u64(79)]; let [v_264]: [G; 1] = [G::from_u64(165)]; let [v_265]: [G; 1] = [G::from_u64(0)]; let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = context.call::<32>(83, 83, &[v_265, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_250, v_251, v_252, v_253, v_254, v_255, v_250, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_249, v_265, v_265, v_265, v_216, v_265, v_265, v_265, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72])?; seed.u8(235, v_266); seed.u8(236, v_267); seed.u8(237, v_268); seed.u8(238, v_269); seed.u8(239, v_270); seed.u8(240, v_271); seed.u8(241, v_272); seed.u8(242, v_273); seed.u8(243, v_274); seed.u8(244, v_275); seed.u8(245, v_276); seed.u8(246, v_277); seed.u8(247, v_278); seed.u8(248, v_279); seed.u8(249, v_280); seed.u8(250, v_281); seed.u8(251, v_282); seed.u8(252, v_283); seed.u8(253, v_284); seed.u8(254, v_285); seed.u8(255, v_286); seed.u8(256, v_287); seed.u8(257, v_288); seed.u8(258, v_289); seed.u8(259, v_290); seed.u8(260, v_291); seed.u8(261, v_292); seed.u8(262, v_293); seed.u8(263, v_294); seed.u8(264, v_295); seed.u8(265, v_296); seed.u32(112, v_297); let [v_298]: [G; 1] = [G::from_u64(1)]; let [v_299]: [G; 1] = context.store(85, &[v_298, v_298, v_298])?; seed.u32(116, v_299); let [v_301]: [G; 1] = context.store(87, &[v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297])?; seed.full(24, v_301); let [v_302]: [G; 1] = context.returned::<1>(88)?; seed.full(32, v_302); Ok(()) }, } } + +fn write_79(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_8]: [G; 1] = [G::from_u64(8)]; let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 64] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_72.as_canonical_u64(); match v_2.as_canonical_u64() { 1023u64 => { let [v_73]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 65] = v_73.as_canonical_u64(); let [v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81]: [G; 8] = [G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79])]; row[offsets.auxiliaries + 66] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = [G::from_u64(seed[80])]; row[offsets.auxiliaries + 74] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [v_73 * v_82]; row[offsets.auxiliaries + 75] = v_83.as_canonical_u64(); let [v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147, v_148]: [G; 32] = [G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112])]; row[offsets.auxiliaries + 76] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_148.as_canonical_u64(); let [v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181, v_182]: [G; 32] = [G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144])]; row[offsets.auxiliaries + 108] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = [G::from_u64(seed[145])]; row[offsets.auxiliaries + 140] = v_183.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 141] = v_185.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191, v_192, v_193]: [G; 8] = [G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154])]; row[offsets.auxiliaries + 142] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_193.as_canonical_u64(); let [v_194]: [G; 1] = [G::from_u64(seed[155])]; row[offsets.auxiliaries + 150] = v_194.as_canonical_u64(); let [v_195]: [G; 1] = [G::from_u64(seed[156])]; row[offsets.auxiliaries + 151] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [G::from_u64(seed[157])]; row[offsets.auxiliaries + 152] = v_196.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 65] = (v_2 - G::from_u64(1023)).inverse().as_canonical_u64(); let [v_197]: [G; 1] = [G::from_u64(seed[71])]; row[offsets.auxiliaries + 66] = v_197.as_canonical_u64(); let [v_199]: [G; 1] = [G::from_u64(seed[72])]; row[offsets.auxiliaries + 67] = v_199.as_canonical_u64(); let [v_200, v_201, v_202, v_203, v_204, v_205, v_206, v_207]: [G; 8] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 68] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_207.as_canonical_u64(); let [v_208]: [G; 1] = [G::from_u64(seed[81])]; row[offsets.auxiliaries + 76] = v_208.as_canonical_u64(); let [v_209]: [G; 1] = [v_208 * v_8]; let [v_210]: [G; 1] = [v_199 * v_209]; row[offsets.auxiliaries + 77] = v_210.as_canonical_u64(); let [v_211]: [G; 1] = [G::from_u64(63)]; let [v_212]: [G; 1] = [v_2 - v_211]; let [v_213]: [G; 1] = [G::from_bool(v_212.is_zero())]; row[offsets.auxiliaries + 78] = g_inverse_value(v_212).as_canonical_u64(); row[offsets.auxiliaries + 79] = v_213.as_canonical_u64(); let [v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248]: [G; 32] = [G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104]), G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107]), G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113])]; row[offsets.auxiliaries + 80] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_223.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_248.as_canonical_u64(); let [v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297]: [G; 32] = [G::from_u64(seed[114]), G::from_u64(seed[115]), G::from_u64(seed[116]), G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145])]; row[offsets.auxiliaries + 112] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_273.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_277.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_279.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_281.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_283.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_284.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_285.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_286.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_287.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_297.as_canonical_u64(); let [v_299]: [G; 1] = [G::from_u64(seed[146])]; row[offsets.auxiliaries + 144] = v_299.as_canonical_u64(); let [v_301]: [G; 1] = [G::from_u64(seed[147])]; row[offsets.auxiliaries + 145] = v_301.as_canonical_u64(); let [v_302]: [G; 1] = [G::from_u64(seed[148])]; row[offsets.auxiliaries + 146] = v_302.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_79: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 96, 100, 8, 104, 108, 16, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 112, 116, 24, 32, 40, 48, 56, 64, 72, 80, 120, 124, 88], bytes: 272 }; + +fn pack_83(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_83_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn write_83(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_83: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_100(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = context.store(2, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed[4] = v_4.as_canonical_u64(); Ok(()) }, _ => { let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = context.call::<10>(3, 87, &[v_0])?; seed[3] = v_5.as_canonical_u64(); seed[4] = v_6.as_canonical_u64(); seed[5] = v_7.as_canonical_u64(); seed[6] = v_8.as_canonical_u64(); seed[7] = v_9.as_canonical_u64(); seed[8] = v_10.as_canonical_u64(); seed[9] = v_11.as_canonical_u64(); seed[10] = v_12.as_canonical_u64(); seed[11] = v_13.as_canonical_u64(); seed[12] = v_14.as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = context.call::<10>(4, 87, &[v_14])?; seed[13] = v_15.as_canonical_u64(); seed[14] = v_16.as_canonical_u64(); seed[15] = v_17.as_canonical_u64(); seed[16] = v_18.as_canonical_u64(); seed[17] = v_19.as_canonical_u64(); seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); seed[20] = v_22.as_canonical_u64(); seed[21] = v_23.as_canonical_u64(); seed[22] = v_24.as_canonical_u64(); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = context.call::<10>(5, 88, &[v_24])?; seed[23] = v_25.as_canonical_u64(); seed[24] = v_26.as_canonical_u64(); seed[25] = v_27.as_canonical_u64(); seed[26] = v_28.as_canonical_u64(); seed[27] = v_29.as_canonical_u64(); seed[28] = v_30.as_canonical_u64(); seed[29] = v_31.as_canonical_u64(); seed[30] = v_32.as_canonical_u64(); seed[31] = v_33.as_canonical_u64(); seed[32] = v_34.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = context.call::<10>(6, 87, &[v_34])?; seed[33] = v_35.as_canonical_u64(); seed[34] = v_36.as_canonical_u64(); seed[35] = v_37.as_canonical_u64(); seed[36] = v_38.as_canonical_u64(); seed[37] = v_39.as_canonical_u64(); seed[38] = v_40.as_canonical_u64(); seed[39] = v_41.as_canonical_u64(); seed[40] = v_42.as_canonical_u64(); seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); let [v_45, v_46]: [G; 2] = context.call::<2>(7, 85, &[v_44])?; seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); let [v_47, v_48]: [G; 2] = context.call::<2>(8, 86, &[v_46])?; seed[45] = v_47.as_canonical_u64(); seed[46] = v_48.as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50, v_51]: [G; 2] = context.call::<2>(10, 93, &[v_48, v_47, v_49])?; seed[47] = v_50.as_canonical_u64(); seed[48] = v_51.as_canonical_u64(); let [v_52, v_53]: [G; 2] = context.call::<2>(11, 86, &[v_51])?; seed[49] = v_52.as_canonical_u64(); seed[50] = v_53.as_canonical_u64(); let [v_54, v_55]: [G; 2] = context.call::<2>(12, 94, &[v_53, v_52])?; seed[51] = v_54.as_canonical_u64(); seed[52] = v_55.as_canonical_u64(); let [v_56, v_57]: [G; 2] = context.call::<2>(13, 86, &[v_55])?; seed[53] = v_56.as_canonical_u64(); seed[54] = v_57.as_canonical_u64(); let [v_58, v_59]: [G; 2] = context.call::<2>(14, 96, &[v_57, v_56])?; seed[55] = v_58.as_canonical_u64(); seed[56] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(15, 97, &[v_56, v_49, v_45])?; seed[57] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_176]: [G; 1] = [v_1 - v_104]; let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(129, 100, &[v_59, v_176])?; seed[58] = v_177.as_canonical_u64(); seed[59] = v_178.as_canonical_u64(); seed[60] = v_179.as_canonical_u64(); let [v_180]: [G; 1] = context.store(130, &[v_49, v_50, v_47, v_54, v_35, v_58, v_45, v_5, v_15, v_63, v_177])?; seed[61] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = context.store(131, &[v_49, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_178])?; seed[62] = v_181.as_canonical_u64(); let [v_182]: [G; 1] = context.store(132, &[v_49, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_181])?; seed[63] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = context.store(133, &[v_49, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_182])?; seed[64] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = context.store(134, &[v_49, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_183])?; seed[65] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = context.store(135, &[v_49, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_184])?; seed[66] = v_185.as_canonical_u64(); let [v_186]: [G; 1] = context.store(136, &[v_49, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_185])?; seed[67] = v_186.as_canonical_u64(); let [v_187]: [G; 1] = context.store(137, &[v_49, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_186])?; seed[68] = v_187.as_canonical_u64(); Ok(()) }, } } + +fn pack_100_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_1.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [G::from_u64(1)]; let [v_3]: [G; 1] = context.store(1, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed.full(16, v_3); let [v_4]: [G; 1] = context.store(2, &[v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2, v_2])?; seed.full(24, v_4); Ok(()) }, _ => { let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = context.call::<10>(3, 87, &[v_0])?; seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(276, v_8); seed.u8(277, v_9); seed.u8(278, v_10); seed.u8(279, v_11); seed.u8(280, v_12); seed.u8(281, v_13); seed.u32(180, v_14); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = context.call::<10>(4, 87, &[v_14])?; seed.full(40, v_15); seed.full(48, v_16); seed.full(56, v_17); seed.u8(282, v_18); seed.u8(283, v_19); seed.u8(284, v_20); seed.u8(285, v_21); seed.u8(286, v_22); seed.u8(287, v_23); seed.u32(184, v_24); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = context.call::<10>(5, 88, &[v_24])?; seed.full(64, v_25); seed.full(72, v_26); seed.full(80, v_27); seed.full(88, v_28); seed.full(96, v_29); seed.u8(288, v_30); seed.u8(289, v_31); seed.u8(290, v_32); seed.u8(291, v_33); seed.u32(188, v_34); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = context.call::<10>(6, 87, &[v_34])?; seed.full(104, v_35); seed.full(112, v_36); seed.full(120, v_37); seed.u8(292, v_38); seed.u8(293, v_39); seed.u8(294, v_40); seed.u8(295, v_41); seed.u8(296, v_42); seed.u8(297, v_43); seed.u32(192, v_44); let [v_45, v_46]: [G; 2] = context.call::<2>(7, 85, &[v_44])?; seed.full(128, v_45); seed.u32(196, v_46); let [v_47, v_48]: [G; 2] = context.call::<2>(8, 86, &[v_46])?; seed.full(136, v_47); seed.u32(200, v_48); let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50, v_51]: [G; 2] = context.call::<2>(10, 93, &[v_48, v_47, v_49])?; seed.u32(204, v_50); seed.u32(208, v_51); let [v_52, v_53]: [G; 2] = context.call::<2>(11, 86, &[v_51])?; seed.full(144, v_52); seed.u32(212, v_53); let [v_54, v_55]: [G; 2] = context.call::<2>(12, 94, &[v_53, v_52])?; seed.u32(216, v_54); seed.u32(220, v_55); let [v_56, v_57]: [G; 2] = context.call::<2>(13, 86, &[v_55])?; seed.full(152, v_56); seed.u32(224, v_57); let [v_58, v_59]: [G; 2] = context.call::<2>(14, 96, &[v_57, v_56])?; seed.u32(228, v_58); seed.u32(232, v_59); let [v_60]: [G; 1] = context.call::<1>(15, 97, &[v_56, v_49, v_45])?; seed.full(160, v_60); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); let [v_176]: [G; 1] = [v_1 - v_104]; let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(129, 100, &[v_59, v_176])?; seed.u32(236, v_177); seed.u32(240, v_178); seed.full(168, v_179); let [v_180]: [G; 1] = context.store(130, &[v_49, v_50, v_47, v_54, v_35, v_58, v_45, v_5, v_15, v_63, v_177])?; seed.u32(244, v_180); let [v_181]: [G; 1] = context.store(131, &[v_49, v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149, v_178])?; seed.u32(248, v_181); let [v_182]: [G; 1] = context.store(132, &[v_49, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_181])?; seed.u32(252, v_182); let [v_183]: [G; 1] = context.store(133, &[v_49, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_182])?; seed.u32(256, v_183); let [v_184]: [G; 1] = context.store(134, &[v_49, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_183])?; seed.u32(260, v_184); let [v_185]: [G; 1] = context.store(135, &[v_49, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_184])?; seed.u32(264, v_185); let [v_186]: [G; 1] = context.store(136, &[v_49, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_185])?; seed.u32(268, v_186); let [v_187]: [G; 1] = context.store(137, &[v_49, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_186])?; seed.u32(272, v_187); Ok(()) }, } } + +fn write_100(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); match v_1.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 10] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 10] = [G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_24.as_canonical_u64(); let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 10] = [G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32])]; row[offsets.auxiliaries + 22] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_34.as_canonical_u64(); let [v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44]: [G; 10] = [G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42])]; row[offsets.auxiliaries + 32] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_44.as_canonical_u64(); let [v_45, v_46]: [G; 2] = [G::from_u64(seed[43]), G::from_u64(seed[44])]; row[offsets.auxiliaries + 42] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_46.as_canonical_u64(); let [v_47, v_48]: [G; 2] = [G::from_u64(seed[45]), G::from_u64(seed[46])]; row[offsets.auxiliaries + 44] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_48.as_canonical_u64(); let [v_50, v_51]: [G; 2] = [G::from_u64(seed[47]), G::from_u64(seed[48])]; row[offsets.auxiliaries + 46] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_51.as_canonical_u64(); let [v_52, v_53]: [G; 2] = [G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 48] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_53.as_canonical_u64(); let [v_54, v_55]: [G; 2] = [G::from_u64(seed[51]), G::from_u64(seed[52])]; row[offsets.auxiliaries + 50] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_55.as_canonical_u64(); let [v_56, v_57]: [G; 2] = [G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 52] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_57.as_canonical_u64(); let [v_58, v_59]: [G; 2] = [G::from_u64(seed[55]), G::from_u64(seed[56])]; row[offsets.auxiliaries + 54] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 56] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; row[offsets.auxiliaries + 57] = g_inverse_value(v_60).as_canonical_u64(); row[offsets.auxiliaries + 58] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = [v_60 + v_61]; let [v_63]: [G; 1] = [v_62 + v_62]; let [v_64]: [G; 1] = [v_52 + v_63]; let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = v_64.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 59] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_72.as_canonical_u64(); let [v_94]: [G; 1] = [G::from_u64(1020)]; let [v_95]: [G; 1] = [v_72 - v_94]; let [v_96]: [G; 1] = [v_71 + v_95]; let [v_97]: [G; 1] = [v_70 + v_96]; let [v_98]: [G; 1] = [v_69 + v_97]; let [v_99]: [G; 1] = [G::from_bool(v_98.is_zero())]; row[offsets.auxiliaries + 67] = g_inverse_value(v_98).as_canonical_u64(); row[offsets.auxiliaries + 68] = v_99.as_canonical_u64(); let [v_100]: [G; 1] = [v_67 + v_68]; let [v_101]: [G; 1] = [v_66 + v_100]; let [v_102]: [G; 1] = [v_65 + v_101]; let [v_103]: [G; 1] = [G::from_bool(v_102.is_zero())]; row[offsets.auxiliaries + 69] = g_inverse_value(v_102).as_canonical_u64(); row[offsets.auxiliaries + 70] = v_103.as_canonical_u64(); let [v_104]: [G; 1] = [G::from_u64(1)]; let [v_105]: [G; 1] = [v_104 - v_103]; let [v_106]: [G; 1] = [v_99 * v_105]; row[offsets.auxiliaries + 71] = v_106.as_canonical_u64(); let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_63.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 72] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_115.as_canonical_u64(); let [v_130]: [G; 1] = [v_115 - v_94]; let [v_131]: [G; 1] = [v_114 + v_130]; let [v_132]: [G; 1] = [v_113 + v_131]; let [v_133]: [G; 1] = [v_112 + v_132]; let [v_134]: [G; 1] = [G::from_bool(v_133.is_zero())]; row[offsets.auxiliaries + 80] = g_inverse_value(v_133).as_canonical_u64(); row[offsets.auxiliaries + 81] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [v_110 + v_111]; let [v_136]: [G; 1] = [v_109 + v_135]; let [v_137]: [G; 1] = [v_108 + v_136]; let [v_138]: [G; 1] = [G::from_bool(v_137.is_zero())]; row[offsets.auxiliaries + 82] = g_inverse_value(v_137).as_canonical_u64(); row[offsets.auxiliaries + 83] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [v_104 - v_138]; let [v_140]: [G; 1] = [v_134 * v_139]; row[offsets.auxiliaries + 84] = v_140.as_canonical_u64(); let [v_142, v_143, v_144, v_145, v_146, v_147, v_148, v_149]: [G; 8] = v_45.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 85] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_149.as_canonical_u64(); let [v_164]: [G; 1] = [v_149 - v_94]; let [v_165]: [G; 1] = [v_148 + v_164]; let [v_166]: [G; 1] = [v_147 + v_165]; let [v_167]: [G; 1] = [v_146 + v_166]; let [v_168]: [G; 1] = [G::from_bool(v_167.is_zero())]; row[offsets.auxiliaries + 93] = g_inverse_value(v_167).as_canonical_u64(); row[offsets.auxiliaries + 94] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [v_144 + v_145]; let [v_170]: [G; 1] = [v_143 + v_169]; let [v_171]: [G; 1] = [v_142 + v_170]; let [v_172]: [G; 1] = [G::from_bool(v_171.is_zero())]; row[offsets.auxiliaries + 95] = g_inverse_value(v_171).as_canonical_u64(); row[offsets.auxiliaries + 96] = v_172.as_canonical_u64(); let [v_173]: [G; 1] = [v_104 - v_172]; let [v_174]: [G; 1] = [v_168 * v_173]; row[offsets.auxiliaries + 97] = v_174.as_canonical_u64(); let [v_177, v_178, v_179]: [G; 3] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 98] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_179.as_canonical_u64(); let [v_180]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 101] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = [G::from_u64(seed[62])]; row[offsets.auxiliaries + 102] = v_181.as_canonical_u64(); let [v_182]: [G; 1] = [G::from_u64(seed[63])]; row[offsets.auxiliaries + 103] = v_182.as_canonical_u64(); let [v_183]: [G; 1] = [G::from_u64(seed[64])]; row[offsets.auxiliaries + 104] = v_183.as_canonical_u64(); let [v_184]: [G; 1] = [G::from_u64(seed[65])]; row[offsets.auxiliaries + 105] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(seed[66])]; row[offsets.auxiliaries + 106] = v_185.as_canonical_u64(); let [v_186]: [G; 1] = [G::from_u64(seed[67])]; row[offsets.auxiliaries + 107] = v_186.as_canonical_u64(); let [v_187]: [G; 1] = [G::from_u64(seed[68])]; row[offsets.auxiliaries + 108] = v_187.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_100: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 176, 8, 16, 24, 32, 276, 277, 278, 279, 280, 281, 180, 40, 48, 56, 282, 283, 284, 285, 286, 287, 184, 64, 72, 80, 88, 96, 288, 289, 290, 291, 188, 104, 112, 120, 292, 293, 294, 295, 296, 297, 192, 128, 196, 136, 200, 204, 208, 144, 212, 216, 220, 152, 224, 228, 232, 160, 236, 240, 168, 244, 248, 252, 256, 260, 264, 268, 272], bytes: 304 }; + +fn pack_114(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 113, &[v_0, v_1])?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 32] = context.load::<32>(2, v_4)?; seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); seed[32] = v_31.as_canonical_u64(); seed[33] = v_32.as_canonical_u64(); seed[34] = v_33.as_canonical_u64(); seed[35] = v_34.as_canonical_u64(); seed[36] = v_35.as_canonical_u64(); seed[37] = v_36.as_canonical_u64(); seed[38] = v_37.as_canonical_u64(); seed[39] = v_38.as_canonical_u64(); seed[40] = v_39.as_canonical_u64(); seed[41] = v_40.as_canonical_u64(); seed[42] = v_41.as_canonical_u64(); seed[43] = v_42.as_canonical_u64(); seed[44] = v_43.as_canonical_u64(); seed[45] = v_44.as_canonical_u64(); seed[46] = v_45.as_canonical_u64(); seed[47] = v_46.as_canonical_u64(); seed[48] = v_47.as_canonical_u64(); seed[49] = v_48.as_canonical_u64(); seed[50] = v_49.as_canonical_u64(); seed[51] = v_50.as_canonical_u64(); seed[52] = v_51.as_canonical_u64(); seed[53] = v_52.as_canonical_u64(); seed[54] = v_53.as_canonical_u64(); seed[55] = v_54.as_canonical_u64(); seed[56] = v_55.as_canonical_u64(); seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed[58] = v_58.as_canonical_u64(); seed[59] = v_59.as_canonical_u64(); seed[60] = v_60.as_canonical_u64(); seed[61] = v_61.as_canonical_u64(); seed[62] = v_62.as_canonical_u64(); seed[63] = v_63.as_canonical_u64(); seed[64] = v_64.as_canonical_u64(); seed[65] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113]: [G; 32] = context.call::<32>(21, 83, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed[66] = v_82.as_canonical_u64(); seed[67] = v_83.as_canonical_u64(); seed[68] = v_84.as_canonical_u64(); seed[69] = v_85.as_canonical_u64(); seed[70] = v_86.as_canonical_u64(); seed[71] = v_87.as_canonical_u64(); seed[72] = v_88.as_canonical_u64(); seed[73] = v_89.as_canonical_u64(); seed[74] = v_90.as_canonical_u64(); seed[75] = v_91.as_canonical_u64(); seed[76] = v_92.as_canonical_u64(); seed[77] = v_93.as_canonical_u64(); seed[78] = v_94.as_canonical_u64(); seed[79] = v_95.as_canonical_u64(); seed[80] = v_96.as_canonical_u64(); seed[81] = v_97.as_canonical_u64(); seed[82] = v_98.as_canonical_u64(); seed[83] = v_99.as_canonical_u64(); seed[84] = v_100.as_canonical_u64(); seed[85] = v_101.as_canonical_u64(); seed[86] = v_102.as_canonical_u64(); seed[87] = v_103.as_canonical_u64(); seed[88] = v_104.as_canonical_u64(); seed[89] = v_105.as_canonical_u64(); seed[90] = v_106.as_canonical_u64(); seed[91] = v_107.as_canonical_u64(); seed[92] = v_108.as_canonical_u64(); seed[93] = v_109.as_canonical_u64(); seed[94] = v_110.as_canonical_u64(); seed[95] = v_111.as_canonical_u64(); seed[96] = v_112.as_canonical_u64(); seed[97] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113])?; seed[98] = v_114.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 113, &[v_14, v_15])?; seed[18] = v_115.as_canonical_u64(); seed[19] = v_116.as_canonical_u64(); seed[20] = v_117.as_canonical_u64(); seed[21] = v_118.as_canonical_u64(); seed[22] = v_119.as_canonical_u64(); seed[23] = v_120.as_canonical_u64(); seed[24] = v_121.as_canonical_u64(); seed[25] = v_122.as_canonical_u64(); seed[26] = v_123.as_canonical_u64(); seed[27] = v_124.as_canonical_u64(); seed[28] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 113, &[v_123, v_124])?; seed[29] = v_126.as_canonical_u64(); seed[30] = v_127.as_canonical_u64(); seed[31] = v_128.as_canonical_u64(); seed[32] = v_129.as_canonical_u64(); seed[33] = v_130.as_canonical_u64(); seed[34] = v_131.as_canonical_u64(); seed[35] = v_132.as_canonical_u64(); seed[36] = v_133.as_canonical_u64(); seed[37] = v_134.as_canonical_u64(); seed[38] = v_135.as_canonical_u64(); seed[39] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 113, &[v_134, v_135])?; seed[40] = v_137.as_canonical_u64(); seed[41] = v_138.as_canonical_u64(); seed[42] = v_139.as_canonical_u64(); seed[43] = v_140.as_canonical_u64(); seed[44] = v_141.as_canonical_u64(); seed[45] = v_142.as_canonical_u64(); seed[46] = v_143.as_canonical_u64(); seed[47] = v_144.as_canonical_u64(); seed[48] = v_145.as_canonical_u64(); seed[49] = v_146.as_canonical_u64(); seed[50] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 113, &[v_145, v_146])?; seed[51] = v_148.as_canonical_u64(); seed[52] = v_149.as_canonical_u64(); seed[53] = v_150.as_canonical_u64(); seed[54] = v_151.as_canonical_u64(); seed[55] = v_152.as_canonical_u64(); seed[56] = v_153.as_canonical_u64(); seed[57] = v_154.as_canonical_u64(); seed[58] = v_155.as_canonical_u64(); seed[59] = v_156.as_canonical_u64(); seed[60] = v_157.as_canonical_u64(); seed[61] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 113, &[v_156, v_157])?; seed[62] = v_159.as_canonical_u64(); seed[63] = v_160.as_canonical_u64(); seed[64] = v_161.as_canonical_u64(); seed[65] = v_162.as_canonical_u64(); seed[66] = v_163.as_canonical_u64(); seed[67] = v_164.as_canonical_u64(); seed[68] = v_165.as_canonical_u64(); seed[69] = v_166.as_canonical_u64(); seed[70] = v_167.as_canonical_u64(); seed[71] = v_168.as_canonical_u64(); seed[72] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 113, &[v_167, v_168])?; seed[73] = v_170.as_canonical_u64(); seed[74] = v_171.as_canonical_u64(); seed[75] = v_172.as_canonical_u64(); seed[76] = v_173.as_canonical_u64(); seed[77] = v_174.as_canonical_u64(); seed[78] = v_175.as_canonical_u64(); seed[79] = v_176.as_canonical_u64(); seed[80] = v_177.as_canonical_u64(); seed[81] = v_178.as_canonical_u64(); seed[82] = v_179.as_canonical_u64(); seed[83] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 113, &[v_178, v_179])?; seed[84] = v_181.as_canonical_u64(); seed[85] = v_182.as_canonical_u64(); seed[86] = v_183.as_canonical_u64(); seed[87] = v_184.as_canonical_u64(); seed[88] = v_185.as_canonical_u64(); seed[89] = v_186.as_canonical_u64(); seed[90] = v_187.as_canonical_u64(); seed[91] = v_188.as_canonical_u64(); seed[92] = v_189.as_canonical_u64(); seed[93] = v_190.as_canonical_u64(); seed[94] = v_191.as_canonical_u64(); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed[95] = v_201.as_canonical_u64(); seed[96] = v_202.as_canonical_u64(); seed[97] = v_203.as_canonical_u64(); seed[98] = v_204.as_canonical_u64(); seed[99] = v_205.as_canonical_u64(); seed[100] = v_206.as_canonical_u64(); seed[101] = v_207.as_canonical_u64(); seed[102] = v_208.as_canonical_u64(); seed[103] = v_209.as_canonical_u64(); seed[104] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed[105] = v_211.as_canonical_u64(); seed[106] = v_212.as_canonical_u64(); seed[107] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed[108] = v_225.as_canonical_u64(); seed[109] = v_226.as_canonical_u64(); seed[110] = v_227.as_canonical_u64(); seed[111] = v_228.as_canonical_u64(); seed[112] = v_229.as_canonical_u64(); seed[113] = v_230.as_canonical_u64(); seed[114] = v_231.as_canonical_u64(); seed[115] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = context.call::<1>(52, 2, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed[116] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed[117] = v_241.as_canonical_u64(); seed[118] = v_242.as_canonical_u64(); seed[119] = v_243.as_canonical_u64(); seed[120] = v_244.as_canonical_u64(); seed[121] = v_245.as_canonical_u64(); seed[122] = v_246.as_canonical_u64(); seed[123] = v_247.as_canonical_u64(); seed[124] = v_248.as_canonical_u64(); seed[125] = v_249.as_canonical_u64(); seed[126] = v_250.as_canonical_u64(); seed[127] = v_251.as_canonical_u64(); seed[128] = v_252.as_canonical_u64(); seed[129] = v_253.as_canonical_u64(); seed[130] = v_254.as_canonical_u64(); seed[131] = v_255.as_canonical_u64(); seed[132] = v_256.as_canonical_u64(); seed[133] = v_257.as_canonical_u64(); seed[134] = v_258.as_canonical_u64(); seed[135] = v_259.as_canonical_u64(); seed[136] = v_260.as_canonical_u64(); seed[137] = v_261.as_canonical_u64(); seed[138] = v_262.as_canonical_u64(); seed[139] = v_263.as_canonical_u64(); seed[140] = v_264.as_canonical_u64(); seed[141] = v_265.as_canonical_u64(); seed[142] = v_266.as_canonical_u64(); seed[143] = v_267.as_canonical_u64(); seed[144] = v_268.as_canonical_u64(); seed[145] = v_269.as_canonical_u64(); seed[146] = v_270.as_canonical_u64(); seed[147] = v_271.as_canonical_u64(); seed[148] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 83, &[v_288, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed[149] = v_289.as_canonical_u64(); seed[150] = v_290.as_canonical_u64(); seed[151] = v_291.as_canonical_u64(); seed[152] = v_292.as_canonical_u64(); seed[153] = v_293.as_canonical_u64(); seed[154] = v_294.as_canonical_u64(); seed[155] = v_295.as_canonical_u64(); seed[156] = v_296.as_canonical_u64(); seed[157] = v_297.as_canonical_u64(); seed[158] = v_298.as_canonical_u64(); seed[159] = v_299.as_canonical_u64(); seed[160] = v_300.as_canonical_u64(); seed[161] = v_301.as_canonical_u64(); seed[162] = v_302.as_canonical_u64(); seed[163] = v_303.as_canonical_u64(); seed[164] = v_304.as_canonical_u64(); seed[165] = v_305.as_canonical_u64(); seed[166] = v_306.as_canonical_u64(); seed[167] = v_307.as_canonical_u64(); seed[168] = v_308.as_canonical_u64(); seed[169] = v_309.as_canonical_u64(); seed[170] = v_310.as_canonical_u64(); seed[171] = v_311.as_canonical_u64(); seed[172] = v_312.as_canonical_u64(); seed[173] = v_313.as_canonical_u64(); seed[174] = v_314.as_canonical_u64(); seed[175] = v_315.as_canonical_u64(); seed[176] = v_316.as_canonical_u64(); seed[177] = v_317.as_canonical_u64(); seed[178] = v_318.as_canonical_u64(); seed[179] = v_319.as_canonical_u64(); seed[180] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_322.as_canonical_u64(); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed[181] = v_355.as_canonical_u64(); seed[182] = v_356.as_canonical_u64(); seed[183] = v_357.as_canonical_u64(); seed[184] = v_358.as_canonical_u64(); seed[185] = v_359.as_canonical_u64(); seed[186] = v_360.as_canonical_u64(); seed[187] = v_361.as_canonical_u64(); seed[188] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 11, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed[189] = v_363.as_canonical_u64(); seed[190] = v_364.as_canonical_u64(); seed[191] = v_365.as_canonical_u64(); seed[192] = v_366.as_canonical_u64(); seed[193] = v_367.as_canonical_u64(); seed[194] = v_368.as_canonical_u64(); seed[195] = v_369.as_canonical_u64(); seed[196] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed[197] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed[198] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[199] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed[200] = v_374.as_canonical_u64(); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed[181] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed[182] = v_378.as_canonical_u64(); Ok(()) }, } }, } }, } } + +fn pack_114_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = context.call::<11>(0, 113, &[v_0, v_1])?; seed.u8(404, v_6); seed.u8(405, v_7); seed.u8(406, v_8); seed.u8(407, v_9); seed.u8(408, v_10); seed.u8(409, v_11); seed.u8(410, v_12); seed.u8(411, v_13); seed.u32(328, v_14); seed.u32(332, v_15); seed.u8(412, v_16); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = context.load::<8>(1, v_3)?; seed.full(24, v_17); seed.full(32, v_18); seed.full(40, v_19); seed.full(48, v_20); seed.full(56, v_21); seed.full(64, v_22); seed.full(72, v_23); seed.full(80, v_24); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 32] = context.load::<32>(2, v_4)?; seed.u32(336, v_25); seed.u32(340, v_26); seed.u8(413, v_27); seed.u8(414, v_28); seed.u8(415, v_29); seed.u8(416, v_30); seed.u8(417, v_31); seed.u8(418, v_32); seed.u8(419, v_33); seed.u8(420, v_34); seed.u8(421, v_35); seed.u32(344, v_36); seed.u32(348, v_37); seed.u8(422, v_38); seed.u8(423, v_39); seed.u8(424, v_40); seed.u8(425, v_41); seed.u8(426, v_42); seed.u8(427, v_43); seed.u8(428, v_44); seed.u8(429, v_45); seed.u8(430, v_46); seed.u32(352, v_47); seed.u32(356, v_48); seed.u8(431, v_49); seed.u8(432, v_50); seed.u8(433, v_51); seed.u8(434, v_52); seed.u8(435, v_53); seed.u8(436, v_54); seed.u8(437, v_55); seed.u8(438, v_56); let [v_57]: [G; 1] = [G::from_u64(0)]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = context.load::<8>(4, v_3)?; seed.u8(439, v_58); seed.u32(360, v_59); seed.u32(364, v_60); seed.u8(440, v_61); seed.u8(441, v_62); seed.u8(442, v_63); seed.u8(443, v_64); seed.u8(444, v_65); let [v_66]: [G; 1] = [G::from_u64(11)]; let [v_67]: [G; 1] = [G::from_u64(103)]; let [v_68]: [G; 1] = [G::from_u64(230)]; let [v_69]: [G; 1] = [G::from_u64(9)]; let [v_70]: [G; 1] = [G::from_u64(106)]; let [v_71]: [G; 1] = [G::from_u64(133)]; let [v_72]: [G; 1] = [G::from_u64(174)]; let [v_73]: [G; 1] = [G::from_u64(187)]; let [v_74]: [G; 1] = [G::from_u64(114)]; let [v_75]: [G; 1] = [G::from_u64(243)]; let [v_76]: [G; 1] = [G::from_u64(110)]; let [v_77]: [G; 1] = [G::from_u64(60)]; let [v_78]: [G; 1] = [G::from_u64(58)]; let [v_79]: [G; 1] = [G::from_u64(245)]; let [v_80]: [G; 1] = [G::from_u64(79)]; let [v_81]: [G; 1] = [G::from_u64(165)]; let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113]: [G; 32] = context.call::<32>(21, 83, &[v_57, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_67, v_68, v_69, v_70, v_71, v_72, v_67, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_57, v_57, v_57, v_57, v_66, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57])?; seed.u8(445, v_82); seed.u8(446, v_83); seed.u8(447, v_84); seed.u8(448, v_85); seed.u32(368, v_86); seed.u32(372, v_87); seed.u8(449, v_88); seed.u8(450, v_89); seed.u8(451, v_90); seed.u8(452, v_91); seed.u8(453, v_92); seed.u8(454, v_93); seed.u8(455, v_94); seed.u8(456, v_95); seed.u8(457, v_96); seed.u32(376, v_97); seed.u32(380, v_98); seed.u8(458, v_99); seed.u8(459, v_100); seed.u8(460, v_101); seed.u8(461, v_102); seed.u8(462, v_103); seed.u8(463, v_104); seed.u8(464, v_105); seed.u8(465, v_106); seed.u8(466, v_107); seed.u32(384, v_108); seed.u32(388, v_109); seed.u8(467, v_110); seed.u8(468, v_111); seed.full(88, v_112); seed.full(96, v_113); let [v_114]: [G; 1] = context.store(22, &[v_57, v_5, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113])?; seed.full(104, v_114); Ok(()) }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = context.call::<11>(23, 113, &[v_14, v_15])?; seed.full(24, v_115); seed.full(32, v_116); seed.full(40, v_117); seed.full(48, v_118); seed.full(56, v_119); seed.full(64, v_120); seed.full(72, v_121); seed.full(80, v_122); seed.u32(336, v_123); seed.u32(340, v_124); seed.u8(413, v_125); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = context.call::<11>(24, 113, &[v_123, v_124])?; seed.u8(414, v_126); seed.u8(415, v_127); seed.u8(416, v_128); seed.u8(417, v_129); seed.u8(418, v_130); seed.u8(419, v_131); seed.u8(420, v_132); seed.u8(421, v_133); seed.u32(344, v_134); seed.u32(348, v_135); seed.u8(422, v_136); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = context.call::<11>(25, 113, &[v_134, v_135])?; seed.u8(423, v_137); seed.u8(424, v_138); seed.u8(425, v_139); seed.u8(426, v_140); seed.u8(427, v_141); seed.u8(428, v_142); seed.u8(429, v_143); seed.u8(430, v_144); seed.u32(352, v_145); seed.u32(356, v_146); seed.u8(431, v_147); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = context.call::<11>(26, 113, &[v_145, v_146])?; seed.u8(432, v_148); seed.u8(433, v_149); seed.u8(434, v_150); seed.u8(435, v_151); seed.u8(436, v_152); seed.u8(437, v_153); seed.u8(438, v_154); seed.u8(439, v_155); seed.u32(360, v_156); seed.u32(364, v_157); seed.u8(440, v_158); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = context.call::<11>(27, 113, &[v_156, v_157])?; seed.u8(441, v_159); seed.u8(442, v_160); seed.u8(443, v_161); seed.u8(444, v_162); seed.u8(445, v_163); seed.u8(446, v_164); seed.u8(447, v_165); seed.u8(448, v_166); seed.u32(368, v_167); seed.u32(372, v_168); seed.u8(449, v_169); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = context.call::<11>(28, 113, &[v_167, v_168])?; seed.u8(450, v_170); seed.u8(451, v_171); seed.u8(452, v_172); seed.u8(453, v_173); seed.u8(454, v_174); seed.u8(455, v_175); seed.u8(456, v_176); seed.u8(457, v_177); seed.u32(376, v_178); seed.u32(380, v_179); seed.u8(458, v_180); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = context.call::<11>(29, 113, &[v_178, v_179])?; seed.u8(459, v_181); seed.u8(460, v_182); seed.u8(461, v_183); seed.u8(462, v_184); seed.u8(463, v_185); seed.u8(464, v_186); seed.u8(465, v_187); seed.u8(466, v_188); seed.u32(384, v_189); seed.u32(388, v_190); seed.u8(467, v_191); let [v_192]: [G; 1] = [G::from_u64(8)]; let [v_193]: [G; 1] = [v_180 + v_191]; let [v_194]: [G; 1] = [v_169 + v_193]; let [v_195]: [G; 1] = [v_158 + v_194]; let [v_196]: [G; 1] = [v_147 + v_195]; let [v_197]: [G; 1] = [v_136 + v_196]; let [v_198]: [G; 1] = [v_125 + v_197]; let [v_199]: [G; 1] = [v_16 + v_198]; let [v_200]: [G; 1] = [v_192 * v_199]; let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = context.load::<10>(39, v_189)?; seed.u8(468, v_201); seed.full(88, v_202); seed.full(96, v_203); seed.full(104, v_204); seed.full(112, v_205); seed.full(120, v_206); seed.full(128, v_207); seed.full(136, v_208); seed.full(144, v_209); seed.full(152, v_210); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = context.load::<3>(40, v_190)?; seed.u8(469, v_211); seed.full(160, v_212); seed.full(168, v_213); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; break 'yield_0 [v_214]; }, _ => { let [v_215]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_215]; }, } }, _ => { let [v_216]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_216]; }, } }; let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; let [v_222]: [G; 1] = [v_217 * v_220]; let [v_223]: [G; 1] = [v_220 - v_222]; let [v_224]: [G; 1] = [v_217 + v_223]; let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = context.load::<8>(51, v_3)?; seed.u8(470, v_225); seed.u8(471, v_226); seed.u8(472, v_227); seed.u8(473, v_228); seed.u8(474, v_229); seed.u8(475, v_230); seed.u8(476, v_231); seed.u8(477, v_232); let [v_233]: [G; 1] = context.call::<1>(52, 2, &[v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232])?; seed.u8(478, v_233); let [v_234]: [G; 1] = [v_217 * v_233]; let [v_235]: [G; 1] = [G::from_u64(2)]; let [v_236]: [G; 1] = [v_235 * v_224]; let [v_237]: [G; 1] = [G::from_u64(8)]; let [v_238]: [G; 1] = [v_237 * v_234]; let [v_239]: [G; 1] = [v_236 + v_238]; let [v_240]: [G; 1] = [v_221 + v_239]; let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = context.load::<32>(60, v_4)?; seed.u8(479, v_241); seed.u8(480, v_242); seed.u8(481, v_243); seed.u8(482, v_244); seed.u8(483, v_245); seed.u8(484, v_246); seed.u8(485, v_247); seed.u8(486, v_248); seed.u8(487, v_249); seed.u8(488, v_250); seed.u8(489, v_251); seed.u8(490, v_252); seed.u8(491, v_253); seed.u8(492, v_254); seed.u8(493, v_255); seed.u8(494, v_256); seed.u8(495, v_257); seed.u8(496, v_258); seed.u8(497, v_259); seed.u8(498, v_260); seed.u8(499, v_261); seed.u8(500, v_262); seed.u8(501, v_263); seed.u8(502, v_264); seed.u8(503, v_265); seed.u8(504, v_266); seed.u8(505, v_267); seed.u8(506, v_268); seed.u8(507, v_269); seed.u8(508, v_270); seed.u8(509, v_271); seed.u8(510, v_272); let [v_273]: [G; 1] = [G::from_u64(103)]; let [v_274]: [G; 1] = [G::from_u64(230)]; let [v_275]: [G; 1] = [G::from_u64(9)]; let [v_276]: [G; 1] = [G::from_u64(106)]; let [v_277]: [G; 1] = [G::from_u64(133)]; let [v_278]: [G; 1] = [G::from_u64(174)]; let [v_279]: [G; 1] = [G::from_u64(187)]; let [v_280]: [G; 1] = [G::from_u64(114)]; let [v_281]: [G; 1] = [G::from_u64(243)]; let [v_282]: [G; 1] = [G::from_u64(110)]; let [v_283]: [G; 1] = [G::from_u64(60)]; let [v_284]: [G; 1] = [G::from_u64(58)]; let [v_285]: [G; 1] = [G::from_u64(245)]; let [v_286]: [G; 1] = [G::from_u64(79)]; let [v_287]: [G; 1] = [G::from_u64(165)]; let [v_288]: [G; 1] = [G::from_u64(0)]; let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = context.call::<32>(77, 83, &[v_288, v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272, v_273, v_274, v_275, v_276, v_277, v_278, v_273, v_279, v_280, v_281, v_282, v_283, v_284, v_285, v_286, v_287, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_200, v_288, v_288, v_288, v_240, v_288, v_288, v_288, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188])?; seed.u8(511, v_289); seed.u8(512, v_290); seed.u8(513, v_291); seed.u8(514, v_292); seed.u8(515, v_293); seed.u8(516, v_294); seed.u8(517, v_295); seed.u8(518, v_296); seed.u8(519, v_297); seed.u8(520, v_298); seed.u8(521, v_299); seed.u8(522, v_300); seed.u8(523, v_301); seed.u8(524, v_302); seed.u8(525, v_303); seed.u8(526, v_304); seed.u8(527, v_305); seed.u8(528, v_306); seed.u8(529, v_307); seed.u8(530, v_308); seed.u8(531, v_309); seed.u8(532, v_310); seed.u8(533, v_311); seed.u8(534, v_312); seed.u8(535, v_313); seed.u8(536, v_314); seed.u8(537, v_315); seed.u8(538, v_316); seed.u8(539, v_317); seed.u8(540, v_318); seed.u8(541, v_319); seed.u8(542, v_320); match v_217.as_canonical_u64() { 1u64 => { let [v_321]: [G; 1] = [G::from_u64(0)]; let [v_322]: [G; 1] = context.store(79, &[v_321, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_322); Ok(()) }, _ => { match v_220.as_canonical_u64() { 1u64 => { let [v_323]: [G; 1] = [G::from_u64(103)]; let [v_324]: [G; 1] = [G::from_u64(230)]; let [v_325]: [G; 1] = [G::from_u64(9)]; let [v_326]: [G; 1] = [G::from_u64(106)]; let [v_327]: [G; 1] = [G::from_u64(133)]; let [v_328]: [G; 1] = [G::from_u64(174)]; let [v_329]: [G; 1] = [G::from_u64(187)]; let [v_330]: [G; 1] = [G::from_u64(114)]; let [v_331]: [G; 1] = [G::from_u64(243)]; let [v_332]: [G; 1] = [G::from_u64(110)]; let [v_333]: [G; 1] = [G::from_u64(60)]; let [v_334]: [G; 1] = [G::from_u64(58)]; let [v_335]: [G; 1] = [G::from_u64(245)]; let [v_336]: [G; 1] = [G::from_u64(79)]; let [v_337]: [G; 1] = [G::from_u64(165)]; let [v_338]: [G; 1] = [G::from_u64(127)]; let [v_339]: [G; 1] = [G::from_u64(82)]; let [v_340]: [G; 1] = [G::from_u64(14)]; let [v_341]: [G; 1] = [G::from_u64(81)]; let [v_342]: [G; 1] = [G::from_u64(140)]; let [v_343]: [G; 1] = [G::from_u64(104)]; let [v_344]: [G; 1] = [G::from_u64(5)]; let [v_345]: [G; 1] = [G::from_u64(155)]; let [v_346]: [G; 1] = [G::from_u64(171)]; let [v_347]: [G; 1] = [G::from_u64(217)]; let [v_348]: [G; 1] = [G::from_u64(131)]; let [v_349]: [G; 1] = [G::from_u64(31)]; let [v_350]: [G; 1] = [G::from_u64(25)]; let [v_351]: [G; 1] = [G::from_u64(205)]; let [v_352]: [G; 1] = [G::from_u64(224)]; let [v_353]: [G; 1] = [G::from_u64(91)]; let [v_354]: [G; 1] = [G::from_u64(0)]; let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = context.load::<8>(112, v_3)?; seed.full(176, v_355); seed.full(184, v_356); seed.full(192, v_357); seed.full(200, v_358); seed.full(208, v_359); seed.full(216, v_360); seed.full(224, v_361); seed.full(232, v_362); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = context.call::<8>(113, 11, &[v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362])?; seed.full(240, v_363); seed.full(248, v_364); seed.full(256, v_365); seed.full(264, v_366); seed.full(272, v_367); seed.full(280, v_368); seed.full(288, v_369); seed.full(296, v_370); let [v_371]: [G; 1] = context.store(114, &[v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370])?; seed.u32(392, v_371); let [v_372]: [G; 1] = context.store(115, &[v_323, v_324, v_325, v_326, v_327, v_328, v_323, v_329, v_330, v_331, v_332, v_333, v_334, v_335, v_336, v_337, v_338, v_339, v_340, v_341, v_342, v_343, v_344, v_345, v_346, v_347, v_348, v_349, v_350, v_351, v_352, v_353])?; seed.u32(396, v_372); let [v_373]: [G; 1] = context.store(116, &[v_354, v_5, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.u32(400, v_373); let [v_374]: [G; 1] = context.returned::<1>(117)?; seed.full(304, v_374); Ok(()) }, _ => { let [v_377]: [G; 1] = context.store(120, &[v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320])?; seed.full(176, v_377); let [v_378]: [G; 1] = context.returned::<1>(121)?; seed.full(184, v_378); Ok(()) }, } }, } }, } } + +fn write_114(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16]: [G; 11] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 8] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); match v_17.as_canonical_u64() { 0u64 => { match v_18.as_canonical_u64() { 0u64 => { match v_19.as_canonical_u64() { 0u64 => { match v_20.as_canonical_u64() { 0u64 => { match v_21.as_canonical_u64() { 0u64 => { match v_22.as_canonical_u64() { 0u64 => { match v_23.as_canonical_u64() { 0u64 => { match v_24.as_canonical_u64() { 0u64 => { let [v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56]: [G; 32] = [G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50]), G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57])]; row[offsets.auxiliaries + 20] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_56.as_canonical_u64(); let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65])]; row[offsets.auxiliaries + 52] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_65.as_canonical_u64(); let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113]: [G; 32] = [G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83]), G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94]), G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97])]; row[offsets.auxiliaries + 60] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_113.as_canonical_u64(); let [v_114]: [G; 1] = [G::from_u64(seed[98])]; row[offsets.auxiliaries + 92] = v_114.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 20] = (v_24 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_23 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_20 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_19 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_18 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 20] = (v_17 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 12] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125]: [G; 11] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28])]; row[offsets.auxiliaries + 13] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_125.as_canonical_u64(); let [v_126, v_127, v_128, v_129, v_130, v_131, v_132, v_133, v_134, v_135, v_136]: [G; 11] = [G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39])]; row[offsets.auxiliaries + 24] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_136.as_canonical_u64(); let [v_137, v_138, v_139, v_140, v_141, v_142, v_143, v_144, v_145, v_146, v_147]: [G; 11] = [G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42]), G::from_u64(seed[43]), G::from_u64(seed[44]), G::from_u64(seed[45]), G::from_u64(seed[46]), G::from_u64(seed[47]), G::from_u64(seed[48]), G::from_u64(seed[49]), G::from_u64(seed[50])]; row[offsets.auxiliaries + 35] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_147.as_canonical_u64(); let [v_148, v_149, v_150, v_151, v_152, v_153, v_154, v_155, v_156, v_157, v_158]: [G; 11] = [G::from_u64(seed[51]), G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54]), G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57]), G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60]), G::from_u64(seed[61])]; row[offsets.auxiliaries + 46] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_158.as_canonical_u64(); let [v_159, v_160, v_161, v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 11] = [G::from_u64(seed[62]), G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66]), G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 57] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_169.as_canonical_u64(); let [v_170, v_171, v_172, v_173, v_174, v_175, v_176, v_177, v_178, v_179, v_180]: [G; 11] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77]), G::from_u64(seed[78]), G::from_u64(seed[79]), G::from_u64(seed[80]), G::from_u64(seed[81]), G::from_u64(seed[82]), G::from_u64(seed[83])]; row[offsets.auxiliaries + 68] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_173.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_180.as_canonical_u64(); let [v_181, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_191]: [G; 11] = [G::from_u64(seed[84]), G::from_u64(seed[85]), G::from_u64(seed[86]), G::from_u64(seed[87]), G::from_u64(seed[88]), G::from_u64(seed[89]), G::from_u64(seed[90]), G::from_u64(seed[91]), G::from_u64(seed[92]), G::from_u64(seed[93]), G::from_u64(seed[94])]; row[offsets.auxiliaries + 79] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_182.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_184.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_191.as_canonical_u64(); let [v_201, v_202, v_203, v_204, v_205, v_206, v_207, v_208, v_209, v_210]: [G; 10] = [G::from_u64(seed[95]), G::from_u64(seed[96]), G::from_u64(seed[97]), G::from_u64(seed[98]), G::from_u64(seed[99]), G::from_u64(seed[100]), G::from_u64(seed[101]), G::from_u64(seed[102]), G::from_u64(seed[103]), G::from_u64(seed[104])]; row[offsets.auxiliaries + 90] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_210.as_canonical_u64(); let [v_217]: [G; 1] = 'yield_0: { match v_201.as_canonical_u64() { 1u64 => { let [v_211, v_212, v_213]: [G; 3] = [G::from_u64(seed[105]), G::from_u64(seed[106]), G::from_u64(seed[107])]; row[offsets.auxiliaries + 100] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_213.as_canonical_u64(); match v_211.as_canonical_u64() { 1u64 => { let [v_214]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); break 'yield_0 [v_214]; }, _ => { row[offsets.auxiliaries + 103] = (v_211 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 10] = G::ONE.as_canonical_u64(); break 'yield_0 [v_215]; }, } }, _ => { row[offsets.auxiliaries + 100] = (v_201 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_216]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 11] = G::ONE.as_canonical_u64(); break 'yield_0 [v_216]; }, } }; row[offsets.auxiliaries + 104] = v_217.as_canonical_u64(); let [v_218]: [G; 1] = [G::from_u64(15)]; let [v_219]: [G; 1] = [v_2 - v_218]; let [v_220]: [G; 1] = [G::from_bool(v_219.is_zero())]; row[offsets.auxiliaries + 105] = g_inverse_value(v_219).as_canonical_u64(); row[offsets.auxiliaries + 106] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_bool(v_2.is_zero())]; row[offsets.auxiliaries + 107] = g_inverse_value(v_2).as_canonical_u64(); row[offsets.auxiliaries + 108] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_217 * v_220]; row[offsets.auxiliaries + 109] = v_222.as_canonical_u64(); let [v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232]: [G; 8] = [G::from_u64(seed[108]), G::from_u64(seed[109]), G::from_u64(seed[110]), G::from_u64(seed[111]), G::from_u64(seed[112]), G::from_u64(seed[113]), G::from_u64(seed[114]), G::from_u64(seed[115])]; row[offsets.auxiliaries + 110] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [G::from_u64(seed[116])]; row[offsets.auxiliaries + 118] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_217 * v_233]; row[offsets.auxiliaries + 119] = v_234.as_canonical_u64(); let [v_241, v_242, v_243, v_244, v_245, v_246, v_247, v_248, v_249, v_250, v_251, v_252, v_253, v_254, v_255, v_256, v_257, v_258, v_259, v_260, v_261, v_262, v_263, v_264, v_265, v_266, v_267, v_268, v_269, v_270, v_271, v_272]: [G; 32] = [G::from_u64(seed[117]), G::from_u64(seed[118]), G::from_u64(seed[119]), G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122]), G::from_u64(seed[123]), G::from_u64(seed[124]), G::from_u64(seed[125]), G::from_u64(seed[126]), G::from_u64(seed[127]), G::from_u64(seed[128]), G::from_u64(seed[129]), G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148])]; row[offsets.auxiliaries + 120] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_264.as_canonical_u64(); row[offsets.auxiliaries + 144] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 145] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 146] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 147] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 148] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 149] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 150] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_272.as_canonical_u64(); let [v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_309, v_310, v_311, v_312, v_313, v_314, v_315, v_316, v_317, v_318, v_319, v_320]: [G; 32] = [G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161]), G::from_u64(seed[162]), G::from_u64(seed[163]), G::from_u64(seed[164]), G::from_u64(seed[165]), G::from_u64(seed[166]), G::from_u64(seed[167]), G::from_u64(seed[168]), G::from_u64(seed[169]), G::from_u64(seed[170]), G::from_u64(seed[171]), G::from_u64(seed[172]), G::from_u64(seed[173]), G::from_u64(seed[174]), G::from_u64(seed[175]), G::from_u64(seed[176]), G::from_u64(seed[177]), G::from_u64(seed[178]), G::from_u64(seed[179]), G::from_u64(seed[180])]; row[offsets.auxiliaries + 152] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 154] = v_291.as_canonical_u64(); row[offsets.auxiliaries + 155] = v_292.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_293.as_canonical_u64(); row[offsets.auxiliaries + 157] = v_294.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_295.as_canonical_u64(); row[offsets.auxiliaries + 159] = v_296.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_297.as_canonical_u64(); row[offsets.auxiliaries + 161] = v_298.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_299.as_canonical_u64(); row[offsets.auxiliaries + 163] = v_300.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 167] = v_304.as_canonical_u64(); row[offsets.auxiliaries + 168] = v_305.as_canonical_u64(); row[offsets.auxiliaries + 169] = v_306.as_canonical_u64(); row[offsets.auxiliaries + 170] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 171] = v_308.as_canonical_u64(); row[offsets.auxiliaries + 172] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 173] = v_310.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_312.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 177] = v_314.as_canonical_u64(); row[offsets.auxiliaries + 178] = v_315.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_316.as_canonical_u64(); row[offsets.auxiliaries + 180] = v_317.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_318.as_canonical_u64(); row[offsets.auxiliaries + 182] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_320.as_canonical_u64(); match v_217.as_canonical_u64() { 1u64 => { let [v_322]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 184] = v_322.as_canonical_u64(); row[offsets.selectors + 12] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 184] = (v_217 - G::from_u64(1)).inverse().as_canonical_u64(); match v_220.as_canonical_u64() { 1u64 => { let [v_355, v_356, v_357, v_358, v_359, v_360, v_361, v_362]: [G; 8] = [G::from_u64(seed[181]), G::from_u64(seed[182]), G::from_u64(seed[183]), G::from_u64(seed[184]), G::from_u64(seed[185]), G::from_u64(seed[186]), G::from_u64(seed[187]), G::from_u64(seed[188])]; row[offsets.auxiliaries + 185] = v_355.as_canonical_u64(); row[offsets.auxiliaries + 186] = v_356.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_357.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_358.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_359.as_canonical_u64(); row[offsets.auxiliaries + 190] = v_360.as_canonical_u64(); row[offsets.auxiliaries + 191] = v_361.as_canonical_u64(); row[offsets.auxiliaries + 192] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367, v_368, v_369, v_370]: [G; 8] = [G::from_u64(seed[189]), G::from_u64(seed[190]), G::from_u64(seed[191]), G::from_u64(seed[192]), G::from_u64(seed[193]), G::from_u64(seed[194]), G::from_u64(seed[195]), G::from_u64(seed[196])]; row[offsets.auxiliaries + 193] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 194] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 195] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 196] = v_366.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_367.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_368.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 200] = v_370.as_canonical_u64(); let [v_371]: [G; 1] = [G::from_u64(seed[197])]; row[offsets.auxiliaries + 201] = v_371.as_canonical_u64(); let [v_372]: [G; 1] = [G::from_u64(seed[198])]; row[offsets.auxiliaries + 202] = v_372.as_canonical_u64(); let [v_373]: [G; 1] = [G::from_u64(seed[199])]; row[offsets.auxiliaries + 203] = v_373.as_canonical_u64(); let [v_374]: [G; 1] = [G::from_u64(seed[200])]; row[offsets.auxiliaries + 204] = v_374.as_canonical_u64(); row[offsets.selectors + 13] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 185] = (v_220 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_377]: [G; 1] = [G::from_u64(seed[181])]; row[offsets.auxiliaries + 186] = v_377.as_canonical_u64(); let [v_378]: [G; 1] = [G::from_u64(seed[182])]; row[offsets.auxiliaries + 187] = v_378.as_canonical_u64(); row[offsets.selectors + 14] = G::ONE.as_canonical_u64(); }, } }, } }, } } + +static SCHEMA_114: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 312, 316, 8, 320, 324, 16, 404, 405, 406, 407, 408, 409, 410, 411, 328, 332, 412, 24, 32, 40, 48, 56, 64, 72, 80, 336, 340, 413, 414, 415, 416, 417, 418, 419, 420, 421, 344, 348, 422, 423, 424, 425, 426, 427, 428, 429, 430, 352, 356, 431, 432, 433, 434, 435, 436, 437, 438, 439, 360, 364, 440, 441, 442, 443, 444, 445, 446, 447, 448, 368, 372, 449, 450, 451, 452, 453, 454, 455, 456, 457, 376, 380, 458, 459, 460, 461, 462, 463, 464, 465, 466, 384, 388, 467, 468, 88, 96, 104, 112, 120, 128, 136, 144, 152, 469, 160, 168, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 392, 396, 400, 304], bytes: 544 }; + +fn pack_172(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(103)]; let [v_6]: [G; 1] = [G::from_u64(230)]; let [v_7]: [G; 1] = [G::from_u64(9)]; let [v_8]: [G; 1] = [G::from_u64(106)]; let [v_9]: [G; 1] = [G::from_u64(133)]; let [v_10]: [G; 1] = [G::from_u64(174)]; let [v_11]: [G; 1] = [G::from_u64(187)]; let [v_12]: [G; 1] = [G::from_u64(114)]; let [v_13]: [G; 1] = [G::from_u64(243)]; let [v_14]: [G; 1] = [G::from_u64(110)]; let [v_15]: [G; 1] = [G::from_u64(60)]; let [v_16]: [G; 1] = [G::from_u64(58)]; let [v_17]: [G; 1] = [G::from_u64(245)]; let [v_18]: [G; 1] = [G::from_u64(79)]; let [v_19]: [G; 1] = [G::from_u64(165)]; let [v_20]: [G; 1] = [G::from_u64(127)]; let [v_21]: [G; 1] = [G::from_u64(82)]; let [v_22]: [G; 1] = [G::from_u64(14)]; let [v_23]: [G; 1] = [G::from_u64(81)]; let [v_24]: [G; 1] = [G::from_u64(140)]; let [v_25]: [G; 1] = [G::from_u64(104)]; let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = [G::from_u64(155)]; let [v_28]: [G; 1] = [G::from_u64(171)]; let [v_29]: [G; 1] = [G::from_u64(217)]; let [v_30]: [G; 1] = [G::from_u64(131)]; let [v_31]: [G; 1] = [G::from_u64(31)]; let [v_32]: [G; 1] = [G::from_u64(25)]; let [v_33]: [G; 1] = [G::from_u64(205)]; let [v_34]: [G; 1] = [G::from_u64(224)]; let [v_35]: [G; 1] = [G::from_u64(91)]; let [v_36]: [G; 1] = [G::from_u64(1)]; let [v_37]: [G; 1] = context.store(33, &[v_36, v_36, v_36])?; seed[6] = v_37.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(0)]; let [v_39]: [G; 1] = context.store(35, &[v_38, v_38, v_38, v_38, v_38, v_38, v_38, v_38])?; seed[7] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = context.store(36, &[v_5, v_6, v_7, v_8, v_9, v_10, v_5, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed[8] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.store(37, &[v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36])?; seed[9] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(38, 75, &[v_0, v_37, v_38, v_38, v_39, v_40, v_41])?; seed[10] = v_42.as_canonical_u64(); let [v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74]: [G; 32] = context.call::<32>(39, 74, &[v_42])?; seed[11] = v_43.as_canonical_u64(); seed[12] = v_44.as_canonical_u64(); seed[13] = v_45.as_canonical_u64(); seed[14] = v_46.as_canonical_u64(); seed[15] = v_47.as_canonical_u64(); seed[16] = v_48.as_canonical_u64(); seed[17] = v_49.as_canonical_u64(); seed[18] = v_50.as_canonical_u64(); seed[19] = v_51.as_canonical_u64(); seed[20] = v_52.as_canonical_u64(); seed[21] = v_53.as_canonical_u64(); seed[22] = v_54.as_canonical_u64(); seed[23] = v_55.as_canonical_u64(); seed[24] = v_56.as_canonical_u64(); seed[25] = v_57.as_canonical_u64(); seed[26] = v_58.as_canonical_u64(); seed[27] = v_59.as_canonical_u64(); seed[28] = v_60.as_canonical_u64(); seed[29] = v_61.as_canonical_u64(); seed[30] = v_62.as_canonical_u64(); seed[31] = v_63.as_canonical_u64(); seed[32] = v_64.as_canonical_u64(); seed[33] = v_65.as_canonical_u64(); seed[34] = v_66.as_canonical_u64(); seed[35] = v_67.as_canonical_u64(); seed[36] = v_68.as_canonical_u64(); seed[37] = v_69.as_canonical_u64(); seed[38] = v_70.as_canonical_u64(); seed[39] = v_71.as_canonical_u64(); seed[40] = v_72.as_canonical_u64(); seed[41] = v_73.as_canonical_u64(); seed[42] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(40, 105, &[v_71, v_72, v_73, v_74, v_37])?; seed[43] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = context.call::<1>(41, 105, &[v_67, v_68, v_69, v_70, v_75])?; seed[44] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = context.call::<1>(42, 105, &[v_63, v_64, v_65, v_66, v_76])?; seed[45] = v_77.as_canonical_u64(); let [v_78]: [G; 1] = context.call::<1>(43, 105, &[v_59, v_60, v_61, v_62, v_77])?; seed[46] = v_78.as_canonical_u64(); let [v_79]: [G; 1] = context.call::<1>(44, 105, &[v_55, v_56, v_57, v_58, v_78])?; seed[47] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = context.call::<1>(45, 105, &[v_51, v_52, v_53, v_54, v_79])?; seed[48] = v_80.as_canonical_u64(); let [v_81]: [G; 1] = context.call::<1>(46, 105, &[v_47, v_48, v_49, v_50, v_80])?; seed[49] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = context.call::<1>(47, 105, &[v_43, v_44, v_45, v_46, v_81])?; seed[50] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.call::<1>(48, 126, &[v_82, v_37])?; seed[51] = v_83.as_canonical_u64(); let [v_84, v_85, v_86]: [G; 3] = context.load::<3>(49, v_83)?; seed[52] = v_84.as_canonical_u64(); seed[53] = v_85.as_canonical_u64(); seed[54] = v_86.as_canonical_u64(); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = context.load::<3>(50, v_86)?; seed[55] = v_87.as_canonical_u64(); seed[56] = v_88.as_canonical_u64(); seed[57] = v_89.as_canonical_u64(); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = context.load::<3>(51, v_89)?; seed[58] = v_90.as_canonical_u64(); seed[59] = v_91.as_canonical_u64(); seed[60] = v_92.as_canonical_u64(); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = context.load::<3>(52, v_92)?; seed[61] = v_93.as_canonical_u64(); seed[62] = v_94.as_canonical_u64(); seed[63] = v_95.as_canonical_u64(); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = context.load::<3>(53, v_95)?; seed[64] = v_96.as_canonical_u64(); seed[65] = v_97.as_canonical_u64(); seed[66] = v_98.as_canonical_u64(); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = context.load::<3>(54, v_98)?; seed[67] = v_99.as_canonical_u64(); seed[68] = v_100.as_canonical_u64(); seed[69] = v_101.as_canonical_u64(); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = context.load::<3>(55, v_101)?; seed[70] = v_102.as_canonical_u64(); seed[71] = v_103.as_canonical_u64(); seed[72] = v_104.as_canonical_u64(); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = context.load::<3>(56, v_104)?; seed[73] = v_105.as_canonical_u64(); seed[74] = v_106.as_canonical_u64(); seed[75] = v_107.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = context.load::<3>(57, v_4)?; seed[6] = v_108.as_canonical_u64(); seed[7] = v_109.as_canonical_u64(); seed[8] = v_110.as_canonical_u64(); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = context.load::<3>(58, v_110)?; seed[9] = v_111.as_canonical_u64(); seed[10] = v_112.as_canonical_u64(); seed[11] = v_113.as_canonical_u64(); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = context.load::<3>(59, v_113)?; seed[12] = v_114.as_canonical_u64(); seed[13] = v_115.as_canonical_u64(); seed[14] = v_116.as_canonical_u64(); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = context.load::<3>(60, v_116)?; seed[15] = v_117.as_canonical_u64(); seed[16] = v_118.as_canonical_u64(); seed[17] = v_119.as_canonical_u64(); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = context.load::<3>(61, v_119)?; seed[18] = v_120.as_canonical_u64(); seed[19] = v_121.as_canonical_u64(); seed[20] = v_122.as_canonical_u64(); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = context.load::<3>(62, v_122)?; seed[21] = v_123.as_canonical_u64(); seed[22] = v_124.as_canonical_u64(); seed[23] = v_125.as_canonical_u64(); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = context.load::<3>(63, v_125)?; seed[24] = v_126.as_canonical_u64(); seed[25] = v_127.as_canonical_u64(); seed[26] = v_128.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +fn pack_172_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(448, v_2); seed.full(8, v_3); seed.u32(368, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(103)]; let [v_6]: [G; 1] = [G::from_u64(230)]; let [v_7]: [G; 1] = [G::from_u64(9)]; let [v_8]: [G; 1] = [G::from_u64(106)]; let [v_9]: [G; 1] = [G::from_u64(133)]; let [v_10]: [G; 1] = [G::from_u64(174)]; let [v_11]: [G; 1] = [G::from_u64(187)]; let [v_12]: [G; 1] = [G::from_u64(114)]; let [v_13]: [G; 1] = [G::from_u64(243)]; let [v_14]: [G; 1] = [G::from_u64(110)]; let [v_15]: [G; 1] = [G::from_u64(60)]; let [v_16]: [G; 1] = [G::from_u64(58)]; let [v_17]: [G; 1] = [G::from_u64(245)]; let [v_18]: [G; 1] = [G::from_u64(79)]; let [v_19]: [G; 1] = [G::from_u64(165)]; let [v_20]: [G; 1] = [G::from_u64(127)]; let [v_21]: [G; 1] = [G::from_u64(82)]; let [v_22]: [G; 1] = [G::from_u64(14)]; let [v_23]: [G; 1] = [G::from_u64(81)]; let [v_24]: [G; 1] = [G::from_u64(140)]; let [v_25]: [G; 1] = [G::from_u64(104)]; let [v_26]: [G; 1] = [G::from_u64(5)]; let [v_27]: [G; 1] = [G::from_u64(155)]; let [v_28]: [G; 1] = [G::from_u64(171)]; let [v_29]: [G; 1] = [G::from_u64(217)]; let [v_30]: [G; 1] = [G::from_u64(131)]; let [v_31]: [G; 1] = [G::from_u64(31)]; let [v_32]: [G; 1] = [G::from_u64(25)]; let [v_33]: [G; 1] = [G::from_u64(205)]; let [v_34]: [G; 1] = [G::from_u64(224)]; let [v_35]: [G; 1] = [G::from_u64(91)]; let [v_36]: [G; 1] = [G::from_u64(1)]; let [v_37]: [G; 1] = context.store(33, &[v_36, v_36, v_36])?; seed.u32(372, v_37); let [v_38]: [G; 1] = [G::from_u64(0)]; let [v_39]: [G; 1] = context.store(35, &[v_38, v_38, v_38, v_38, v_38, v_38, v_38, v_38])?; seed.full(16, v_39); let [v_40]: [G; 1] = context.store(36, &[v_5, v_6, v_7, v_8, v_9, v_10, v_5, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35])?; seed.u32(376, v_40); let [v_41]: [G; 1] = context.store(37, &[v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36, v_36])?; seed.u32(380, v_41); let [v_42]: [G; 1] = context.call::<1>(38, 75, &[v_0, v_37, v_38, v_38, v_39, v_40, v_41])?; seed.full(24, v_42); let [v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74]: [G; 32] = context.call::<32>(39, 74, &[v_42])?; seed.full(32, v_43); seed.full(40, v_44); seed.full(48, v_45); seed.full(56, v_46); seed.full(64, v_47); seed.full(72, v_48); seed.full(80, v_49); seed.full(88, v_50); seed.full(96, v_51); seed.full(104, v_52); seed.full(112, v_53); seed.full(120, v_54); seed.full(128, v_55); seed.full(136, v_56); seed.full(144, v_57); seed.full(152, v_58); seed.full(160, v_59); seed.full(168, v_60); seed.full(176, v_61); seed.full(184, v_62); seed.full(192, v_63); seed.full(200, v_64); seed.full(208, v_65); seed.full(216, v_66); seed.full(224, v_67); seed.full(232, v_68); seed.full(240, v_69); seed.full(248, v_70); seed.full(256, v_71); seed.full(264, v_72); seed.full(272, v_73); seed.full(280, v_74); let [v_75]: [G; 1] = context.call::<1>(40, 105, &[v_71, v_72, v_73, v_74, v_37])?; seed.u32(384, v_75); let [v_76]: [G; 1] = context.call::<1>(41, 105, &[v_67, v_68, v_69, v_70, v_75])?; seed.u32(388, v_76); let [v_77]: [G; 1] = context.call::<1>(42, 105, &[v_63, v_64, v_65, v_66, v_76])?; seed.u32(392, v_77); let [v_78]: [G; 1] = context.call::<1>(43, 105, &[v_59, v_60, v_61, v_62, v_77])?; seed.u32(396, v_78); let [v_79]: [G; 1] = context.call::<1>(44, 105, &[v_55, v_56, v_57, v_58, v_78])?; seed.u32(400, v_79); let [v_80]: [G; 1] = context.call::<1>(45, 105, &[v_51, v_52, v_53, v_54, v_79])?; seed.u32(404, v_80); let [v_81]: [G; 1] = context.call::<1>(46, 105, &[v_47, v_48, v_49, v_50, v_80])?; seed.u32(408, v_81); let [v_82]: [G; 1] = context.call::<1>(47, 105, &[v_43, v_44, v_45, v_46, v_81])?; seed.u32(412, v_82); let [v_83]: [G; 1] = context.call::<1>(48, 126, &[v_82, v_37])?; seed.u32(416, v_83); let [v_84, v_85, v_86]: [G; 3] = context.load::<3>(49, v_83)?; seed.u8(449, v_84); seed.full(288, v_85); seed.u32(420, v_86); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = context.load::<3>(50, v_86)?; seed.u8(450, v_87); seed.full(296, v_88); seed.u32(424, v_89); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = context.load::<3>(51, v_89)?; seed.u8(451, v_90); seed.full(304, v_91); seed.u32(428, v_92); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = context.load::<3>(52, v_92)?; seed.u8(452, v_93); seed.full(312, v_94); seed.u32(432, v_95); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = context.load::<3>(53, v_95)?; seed.u8(453, v_96); seed.full(320, v_97); seed.u32(436, v_98); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = context.load::<3>(54, v_98)?; seed.u8(454, v_99); seed.full(328, v_100); seed.u32(440, v_101); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = context.load::<3>(55, v_101)?; seed.u8(455, v_102); seed.full(336, v_103); seed.u32(444, v_104); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = context.load::<3>(56, v_104)?; seed.u8(456, v_105); seed.full(344, v_106); seed.full(352, v_107); Ok(()) }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = context.load::<3>(57, v_4)?; seed.u32(372, v_108); seed.full(16, v_109); seed.u32(376, v_110); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = context.load::<3>(58, v_110)?; seed.u32(380, v_111); seed.full(24, v_112); seed.full(32, v_113); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = context.load::<3>(59, v_113)?; seed.full(40, v_114); seed.full(48, v_115); seed.full(56, v_116); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = context.load::<3>(60, v_116)?; seed.full(64, v_117); seed.full(72, v_118); seed.full(80, v_119); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = context.load::<3>(61, v_119)?; seed.full(88, v_120); seed.full(96, v_121); seed.full(104, v_122); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = context.load::<3>(62, v_122)?; seed.full(112, v_123); seed.full(120, v_124); seed.full(128, v_125); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = context.load::<3>(63, v_125)?; seed.full(136, v_126); seed.full(144, v_127); seed.full(152, v_128); Ok(()) }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +fn write_172(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_37]: [G; 1] = [G::from_u64(seed[6])]; row[offsets.auxiliaries + 4] = v_37.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[7])]; row[offsets.auxiliaries + 5] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 6] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_42.as_canonical_u64(); let [v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74]: [G; 32] = [G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31]), G::from_u64(seed[32]), G::from_u64(seed[33]), G::from_u64(seed[34]), G::from_u64(seed[35]), G::from_u64(seed[36]), G::from_u64(seed[37]), G::from_u64(seed[38]), G::from_u64(seed[39]), G::from_u64(seed[40]), G::from_u64(seed[41]), G::from_u64(seed[42])]; row[offsets.auxiliaries + 9] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [G::from_u64(seed[43])]; row[offsets.auxiliaries + 41] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 42] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(seed[45])]; row[offsets.auxiliaries + 43] = v_77.as_canonical_u64(); let [v_78]: [G; 1] = [G::from_u64(seed[46])]; row[offsets.auxiliaries + 44] = v_78.as_canonical_u64(); let [v_79]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 45] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 46] = v_80.as_canonical_u64(); let [v_81]: [G; 1] = [G::from_u64(seed[49])]; row[offsets.auxiliaries + 47] = v_81.as_canonical_u64(); let [v_82]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 48] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 49] = v_83.as_canonical_u64(); let [v_84, v_85, v_86]: [G; 3] = [G::from_u64(seed[52]), G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 50] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_86.as_canonical_u64(); match v_84.as_canonical_u64() { 0u64 => { let [v_87, v_88, v_89]: [G; 3] = [G::from_u64(seed[55]), G::from_u64(seed[56]), G::from_u64(seed[57])]; row[offsets.auxiliaries + 53] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_89.as_canonical_u64(); match v_87.as_canonical_u64() { 0u64 => { let [v_90, v_91, v_92]: [G; 3] = [G::from_u64(seed[58]), G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 56] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_92.as_canonical_u64(); match v_90.as_canonical_u64() { 0u64 => { let [v_93, v_94, v_95]: [G; 3] = [G::from_u64(seed[61]), G::from_u64(seed[62]), G::from_u64(seed[63])]; row[offsets.auxiliaries + 59] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_95.as_canonical_u64(); match v_93.as_canonical_u64() { 0u64 => { let [v_96, v_97, v_98]: [G; 3] = [G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 62] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_98.as_canonical_u64(); match v_96.as_canonical_u64() { 0u64 => { let [v_99, v_100, v_101]: [G; 3] = [G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 65] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_101.as_canonical_u64(); match v_99.as_canonical_u64() { 0u64 => { let [v_102, v_103, v_104]: [G; 3] = [G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 68] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_104.as_canonical_u64(); match v_102.as_canonical_u64() { 0u64 => { let [v_105, v_106, v_107]: [G; 3] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75])]; row[offsets.auxiliaries + 71] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_107.as_canonical_u64(); match v_105.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_105)) }, } }, _ => { Err(no_match(172, v_102)) }, } }, _ => { Err(no_match(172, v_99)) }, } }, _ => { Err(no_match(172, v_96)) }, } }, _ => { Err(no_match(172, v_93)) }, } }, _ => { Err(no_match(172, v_90)) }, } }, _ => { Err(no_match(172, v_87)) }, } }, _ => { Err(no_match(172, v_84)) }, } }, 0u64 => { let [v_108, v_109, v_110]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_110.as_canonical_u64(); match v_108.as_canonical_u64() { 0u64 => { let [v_111, v_112, v_113]: [G; 3] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11])]; row[offsets.auxiliaries + 7] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_113.as_canonical_u64(); match v_111.as_canonical_u64() { 0u64 => { let [v_114, v_115, v_116]: [G; 3] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 10] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_116.as_canonical_u64(); match v_114.as_canonical_u64() { 0u64 => { let [v_117, v_118, v_119]: [G; 3] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 13] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_119.as_canonical_u64(); match v_117.as_canonical_u64() { 0u64 => { let [v_120, v_121, v_122]: [G; 3] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; row[offsets.auxiliaries + 16] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_122.as_canonical_u64(); match v_120.as_canonical_u64() { 0u64 => { let [v_123, v_124, v_125]: [G; 3] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 19] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_125.as_canonical_u64(); match v_123.as_canonical_u64() { 0u64 => { let [v_126, v_127, v_128]: [G; 3] = [G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26])]; row[offsets.auxiliaries + 22] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_128.as_canonical_u64(); match v_126.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(172, v_126)) }, } }, _ => { Err(no_match(172, v_123)) }, } }, _ => { Err(no_match(172, v_120)) }, } }, _ => { Err(no_match(172, v_117)) }, } }, _ => { Err(no_match(172, v_114)) }, } }, _ => { Err(no_match(172, v_111)) }, } }, _ => { Err(no_match(172, v_108)) }, } }, _ => { Err(no_match(172, v_2)) }, } } + +static SCHEMA_172: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 360, 364, 448, 8, 368, 372, 16, 376, 380, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 384, 388, 392, 396, 400, 404, 408, 412, 416, 449, 288, 420, 450, 296, 424, 451, 304, 428, 452, 312, 432, 453, 320, 436, 454, 328, 440, 455, 336, 444, 456, 344, 352], bytes: 464 }; + +fn pack_200(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = context.load::<11>(0, v_0)?; seed[21] = v_20.as_canonical_u64(); seed[22] = v_21.as_canonical_u64(); seed[23] = v_22.as_canonical_u64(); seed[24] = v_23.as_canonical_u64(); seed[25] = v_24.as_canonical_u64(); seed[26] = v_25.as_canonical_u64(); seed[27] = v_26.as_canonical_u64(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); seed[30] = v_29.as_canonical_u64(); seed[31] = v_30.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = context.call::<1>(2, 239, &[v_2, v_9])?; seed[32] = v_32.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = context.call::<1>(7, 198, &[v_24])?; seed[33] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 250, &[v_3, v_9])?; seed[34] = v_37.as_canonical_u64(); seed[35] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.call::<1>(9, 239, &[v_4, v_9])?; seed[36] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.call::<1>(11, 239, &[v_39, v_40])?; seed[37] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(12, 239, &[v_39, v_35])?; seed[38] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(13, 239, &[v_5, v_9])?; seed[39] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(14, 239, &[v_43, v_40])?; seed[40] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.call::<1>(15, 239, &[v_43, v_35])?; seed[41] = v_45.as_canonical_u64(); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 250, &[v_1, v_9])?; seed[42] = v_46.as_canonical_u64(); seed[43] = v_47.as_canonical_u64(); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; let [v_49]: [G; 1] = context.store(18, &[v_48, v_48, v_48, v_48])?; seed[44] = v_49.as_canonical_u64(); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.store(20, &[v_50, v_50, v_50, v_50])?; seed[44] = v_51.as_canonical_u64(); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = context.call::<1>(21, 239, &[v_7, v_47])?; seed[44] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(23, 239, &[v_52, v_53])?; seed[45] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.call::<1>(25, 239, &[v_52, v_55])?; seed[46] = v_56.as_canonical_u64(); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 242, &[v_41])?; seed[47] = v_59.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = context.call::<1>(31, 242, &[v_42])?; seed[48] = v_63.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(35, 242, &[v_44])?; seed[49] = v_66.as_canonical_u64(); let [v_69]: [G; 1] = context.call::<1>(39, 242, &[v_45])?; seed[50] = v_69.as_canonical_u64(); let [v_72]: [G; 1] = context.call::<1>(43, 242, &[v_57])?; seed[51] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(47, 242, &[v_58])?; seed[52] = v_75.as_canonical_u64(); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 182, &[v_18, v_19, v_32])?; seed[53] = v_78.as_canonical_u64(); seed[54] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = context.call::<1>(55, 183, &[v_32])?; seed[55] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; let [v_101]: [G; 1] = [v_89 * v_96]; let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; let [v_104]: [G; 1] = [v_81 * v_101]; let [v_105]: [G; 1] = [v_82 * v_103]; let [v_106]: [G; 1] = [v_92 * v_105]; let [v_107]: [G; 1] = [v_104 + v_106]; let [v_108]: [G; 1] = [v_81 * v_103]; let [v_109]: [G; 1] = [v_82 * v_101]; let [v_110]: [G; 1] = [v_108 + v_109]; let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; let [v_119]: [G; 1] = [v_111 * v_114]; let [v_120]: [G; 1] = [v_102 * v_114]; let [v_121]: [G; 1] = [v_81 * v_119]; let [v_122]: [G; 1] = [v_82 * v_120]; let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; let [v_126]: [G; 1] = [v_82 * v_119]; let [v_127]: [G; 1] = [v_125 + v_126]; let [v_140]: [G; 1] = context.store(120, &[v_62, v_62, v_62, v_62])?; seed[56] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = context.store(121, &[v_80, v_38, v_80, v_140])?; seed[57] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = context.store(122, &[v_80, v_37, v_80, v_141])?; seed[58] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = context.store(123, &[v_80, v_11, v_80, v_142])?; seed[59] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = context.store(124, &[v_80, v_10, v_80, v_143])?; seed[60] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = context.store(125, &[v_80, v_15, v_80, v_144])?; seed[61] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = context.store(126, &[v_80, v_14, v_80, v_145])?; seed[62] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = context.store(127, &[v_80, v_13, v_80, v_146])?; seed[63] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = context.store(128, &[v_80, v_12, v_80, v_147])?; seed[64] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = context.call::<1>(129, 185, &[v_32])?; seed[65] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(130, 183, &[v_32])?; seed[66] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_149 * v_150]; let [v_152]: [G; 1] = [g_inverse_value(v_151)]; let [v_157, v_158]: [G; 2] = context.call::<2>(139, 191, &[v_80, v_80, v_16, v_17, v_23, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed[67] = v_157.as_canonical_u64(); seed[68] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; let [v_169]: [G; 1] = [v_127 * v_167]; let [v_170]: [G; 1] = [v_92 * v_169]; let [v_171]: [G; 1] = [v_168 + v_170]; let [v_172]: [G; 1] = [v_124 * v_167]; let [v_173]: [G; 1] = [v_127 * v_164]; let [v_174]: [G; 1] = [v_172 + v_173]; let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; let [v_181]: [G; 1] = [v_127 * v_179]; let [v_182]: [G; 1] = [v_92 * v_181]; let [v_183]: [G; 1] = [v_180 + v_182]; let [v_184]: [G; 1] = [v_124 * v_179]; let [v_185]: [G; 1] = [v_127 * v_177]; let [v_186]: [G; 1] = [v_184 + v_185]; let [v_187, v_188, v_189, v_190]: [G; 4] = context.load::<4>(168, v_25)?; seed[69] = v_187.as_canonical_u64(); seed[70] = v_188.as_canonical_u64(); seed[71] = v_189.as_canonical_u64(); seed[72] = v_190.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_191]: [G; 1] = [G::from_u64(0)]; let [v_192, v_193]: [G; 2] = context.call::<2>(170, 250, &[v_45, v_191])?; seed[73] = v_192.as_canonical_u64(); seed[74] = v_193.as_canonical_u64(); let [v_194, v_195]: [G; 2] = context.call::<2>(171, 250, &[v_44, v_191])?; seed[75] = v_194.as_canonical_u64(); seed[76] = v_195.as_canonical_u64(); let [v_196]: [G; 1] = [v_192 - v_194]; let [v_197]: [G; 1] = [v_193 - v_195]; let [v_198]: [G; 1] = [v_196 + v_171]; let [v_199]: [G; 1] = [v_197 + v_174]; let [v_200, v_201]: [G; 2] = context.call::<2>(176, 187, &[v_157, v_158, v_16, v_17, v_198, v_199])?; seed[77] = v_200.as_canonical_u64(); seed[78] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [G::from_u64(1)]; let [v_203, v_204]: [G; 2] = context.call::<2>(178, 250, &[v_45, v_202])?; seed[79] = v_203.as_canonical_u64(); seed[80] = v_204.as_canonical_u64(); let [v_205, v_206]: [G; 2] = context.call::<2>(179, 250, &[v_44, v_202])?; seed[81] = v_205.as_canonical_u64(); seed[82] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [v_203 - v_205]; let [v_208]: [G; 1] = [v_204 - v_206]; let [v_209]: [G; 1] = [v_207 + v_183]; let [v_210]: [G; 1] = [v_208 + v_186]; let [v_211, v_212]: [G; 2] = context.call::<2>(184, 187, &[v_200, v_201, v_16, v_17, v_209, v_210])?; seed[83] = v_211.as_canonical_u64(); seed[84] = v_212.as_canonical_u64(); break 'yield_0 []; }, 0u64 => { let [v_213]: [G; 1] = [G::from_u64(0)]; let [v_214]: [G; 1] = context.call::<1>(186, 242, &[v_25])?; seed[73] = v_214.as_canonical_u64(); let [v_215]: [G; 1] = [G::from_u64(1)]; let [v_216, v_217]: [G; 2] = context.call::<2>(188, 194, &[v_157, v_158, v_16, v_17, v_25, v_213, v_214, v_213, v_26, v_26, v_215, v_213, v_213, v_213, v_213, v_213, v_213, v_213, v_171, v_174, v_183, v_186, v_12, v_80, v_13, v_80, v_14, v_80, v_15, v_80, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed[74] = v_216.as_canonical_u64(); seed[75] = v_217.as_canonical_u64(); break 'yield_0 []; }, _ => { return Err(no_match(200, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 239, &[v_8, v_9])?; seed[85] = v_220.as_canonical_u64(); let [v_221]: [G; 1] = [G::from_u64(0)]; let [v_222]: [G; 1] = context.call::<1>(191, 239, &[v_220, v_221])?; seed[86] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = context.call::<1>(192, 189, &[v_222])?; seed[87] = v_223.as_canonical_u64(); let [v_224]: [G; 1] = context.call::<1>(193, 242, &[v_223])?; seed[88] = v_224.as_canonical_u64(); let [v_227]: [G; 1] = [G::from_u64(1)]; let [v_228, v_229]: [G; 2] = context.call::<2>(198, 182, &[v_18, v_19, v_32])?; seed[89] = v_228.as_canonical_u64(); seed[90] = v_229.as_canonical_u64(); let [v_230, v_231]: [G; 2] = context.call::<2>(199, 197, &[v_223, v_228, v_229, v_227, v_221])?; seed[91] = v_230.as_canonical_u64(); seed[92] = v_231.as_canonical_u64(); let [v_246]: [G; 1] = context.returned::<1>(215)?; seed[93] = v_246.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +fn pack_200_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = context.load::<11>(0, v_0)?; seed.u8(605, v_20); seed.u32(516, v_21); seed.full(152, v_22); seed.u32(520, v_23); seed.full(160, v_24); seed.u32(524, v_25); seed.full(168, v_26); seed.full(176, v_27); seed.full(184, v_28); seed.full(192, v_29); seed.u32(528, v_30); match v_20.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = context.call::<1>(2, 239, &[v_2, v_9])?; seed.u8(606, v_32); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = context.call::<1>(7, 198, &[v_24])?; seed.u8(607, v_36); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 250, &[v_3, v_9])?; seed.full(200, v_37); seed.full(208, v_38); let [v_39]: [G; 1] = context.call::<1>(9, 239, &[v_4, v_9])?; seed.full(216, v_39); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.call::<1>(11, 239, &[v_39, v_40])?; seed.u32(532, v_41); let [v_42]: [G; 1] = context.call::<1>(12, 239, &[v_39, v_35])?; seed.u32(536, v_42); let [v_43]: [G; 1] = context.call::<1>(13, 239, &[v_5, v_9])?; seed.full(224, v_43); let [v_44]: [G; 1] = context.call::<1>(14, 239, &[v_43, v_40])?; seed.u32(540, v_44); let [v_45]: [G; 1] = context.call::<1>(15, 239, &[v_43, v_35])?; seed.u32(544, v_45); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 250, &[v_1, v_9])?; seed.u8(608, v_46); seed.full(232, v_47); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_48]: [G; 1] = [G::from_u64(1)]; let [v_49]: [G; 1] = context.store(18, &[v_48, v_48, v_48, v_48])?; seed.full(240, v_49); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.store(20, &[v_50, v_50, v_50, v_50])?; seed.full(240, v_51); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = context.call::<1>(21, 239, &[v_7, v_47])?; seed.full(240, v_52); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(23, 239, &[v_52, v_53])?; seed.u32(548, v_54); let [v_55]: [G; 1] = [G::from_u64(1)]; let [v_56]: [G; 1] = context.call::<1>(25, 239, &[v_52, v_55])?; seed.u32(552, v_56); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 242, &[v_41])?; seed.full(248, v_59); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = context.call::<1>(31, 242, &[v_42])?; seed.full(256, v_63); let [v_66]: [G; 1] = context.call::<1>(35, 242, &[v_44])?; seed.full(264, v_66); let [v_69]: [G; 1] = context.call::<1>(39, 242, &[v_45])?; seed.full(272, v_69); let [v_72]: [G; 1] = context.call::<1>(43, 242, &[v_57])?; seed.full(280, v_72); let [v_75]: [G; 1] = context.call::<1>(47, 242, &[v_58])?; seed.full(288, v_75); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 182, &[v_18, v_19, v_32])?; seed.full(296, v_78); seed.full(304, v_79); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = context.call::<1>(55, 183, &[v_32])?; seed.full(312, v_83); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; let [v_101]: [G; 1] = [v_89 * v_96]; let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; let [v_104]: [G; 1] = [v_81 * v_101]; let [v_105]: [G; 1] = [v_82 * v_103]; let [v_106]: [G; 1] = [v_92 * v_105]; let [v_107]: [G; 1] = [v_104 + v_106]; let [v_108]: [G; 1] = [v_81 * v_103]; let [v_109]: [G; 1] = [v_82 * v_101]; let [v_110]: [G; 1] = [v_108 + v_109]; let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; let [v_119]: [G; 1] = [v_111 * v_114]; let [v_120]: [G; 1] = [v_102 * v_114]; let [v_121]: [G; 1] = [v_81 * v_119]; let [v_122]: [G; 1] = [v_82 * v_120]; let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; let [v_126]: [G; 1] = [v_82 * v_119]; let [v_127]: [G; 1] = [v_125 + v_126]; let [v_140]: [G; 1] = context.store(120, &[v_62, v_62, v_62, v_62])?; seed.u32(556, v_140); let [v_141]: [G; 1] = context.store(121, &[v_80, v_38, v_80, v_140])?; seed.u32(560, v_141); let [v_142]: [G; 1] = context.store(122, &[v_80, v_37, v_80, v_141])?; seed.u32(564, v_142); let [v_143]: [G; 1] = context.store(123, &[v_80, v_11, v_80, v_142])?; seed.u32(568, v_143); let [v_144]: [G; 1] = context.store(124, &[v_80, v_10, v_80, v_143])?; seed.u32(572, v_144); let [v_145]: [G; 1] = context.store(125, &[v_80, v_15, v_80, v_144])?; seed.u32(576, v_145); let [v_146]: [G; 1] = context.store(126, &[v_80, v_14, v_80, v_145])?; seed.u32(580, v_146); let [v_147]: [G; 1] = context.store(127, &[v_80, v_13, v_80, v_146])?; seed.u32(584, v_147); let [v_148]: [G; 1] = context.store(128, &[v_80, v_12, v_80, v_147])?; seed.u32(588, v_148); let [v_149]: [G; 1] = context.call::<1>(129, 185, &[v_32])?; seed.full(320, v_149); let [v_150]: [G; 1] = context.call::<1>(130, 183, &[v_32])?; seed.full(328, v_150); let [v_151]: [G; 1] = [v_149 * v_150]; let [v_152]: [G; 1] = [g_inverse_value(v_151)]; let [v_157, v_158]: [G; 2] = context.call::<2>(139, 191, &[v_80, v_80, v_16, v_17, v_23, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed.full(336, v_157); seed.full(344, v_158); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; let [v_169]: [G; 1] = [v_127 * v_167]; let [v_170]: [G; 1] = [v_92 * v_169]; let [v_171]: [G; 1] = [v_168 + v_170]; let [v_172]: [G; 1] = [v_124 * v_167]; let [v_173]: [G; 1] = [v_127 * v_164]; let [v_174]: [G; 1] = [v_172 + v_173]; let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; let [v_181]: [G; 1] = [v_127 * v_179]; let [v_182]: [G; 1] = [v_92 * v_181]; let [v_183]: [G; 1] = [v_180 + v_182]; let [v_184]: [G; 1] = [v_124 * v_179]; let [v_185]: [G; 1] = [v_127 * v_177]; let [v_186]: [G; 1] = [v_184 + v_185]; let [v_187, v_188, v_189, v_190]: [G; 4] = context.load::<4>(168, v_25)?; seed.u8(609, v_187); seed.full(352, v_188); seed.full(360, v_189); seed.u32(592, v_190); let []: [G; 0] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_191]: [G; 1] = [G::from_u64(0)]; let [v_192, v_193]: [G; 2] = context.call::<2>(170, 250, &[v_45, v_191])?; seed.full(368, v_192); seed.full(376, v_193); let [v_194, v_195]: [G; 2] = context.call::<2>(171, 250, &[v_44, v_191])?; seed.full(384, v_194); seed.full(392, v_195); let [v_196]: [G; 1] = [v_192 - v_194]; let [v_197]: [G; 1] = [v_193 - v_195]; let [v_198]: [G; 1] = [v_196 + v_171]; let [v_199]: [G; 1] = [v_197 + v_174]; let [v_200, v_201]: [G; 2] = context.call::<2>(176, 187, &[v_157, v_158, v_16, v_17, v_198, v_199])?; seed.full(400, v_200); seed.full(408, v_201); let [v_202]: [G; 1] = [G::from_u64(1)]; let [v_203, v_204]: [G; 2] = context.call::<2>(178, 250, &[v_45, v_202])?; seed.full(416, v_203); seed.full(424, v_204); let [v_205, v_206]: [G; 2] = context.call::<2>(179, 250, &[v_44, v_202])?; seed.full(432, v_205); seed.full(440, v_206); let [v_207]: [G; 1] = [v_203 - v_205]; let [v_208]: [G; 1] = [v_204 - v_206]; let [v_209]: [G; 1] = [v_207 + v_183]; let [v_210]: [G; 1] = [v_208 + v_186]; let [v_211, v_212]: [G; 2] = context.call::<2>(184, 187, &[v_200, v_201, v_16, v_17, v_209, v_210])?; seed.full(448, v_211); seed.full(456, v_212); break 'yield_0 []; }, 0u64 => { let [v_213]: [G; 1] = [G::from_u64(0)]; let [v_214]: [G; 1] = context.call::<1>(186, 242, &[v_25])?; seed.full(368, v_214); let [v_215]: [G; 1] = [G::from_u64(1)]; let [v_216, v_217]: [G; 2] = context.call::<2>(188, 194, &[v_157, v_158, v_16, v_17, v_25, v_213, v_214, v_213, v_26, v_26, v_215, v_213, v_213, v_213, v_213, v_213, v_213, v_213, v_171, v_174, v_183, v_186, v_12, v_80, v_13, v_80, v_14, v_80, v_15, v_80, v_21, v_41, v_42, v_57, v_58, v_44, v_45, v_148, v_107, v_110, v_124, v_127, v_111, v_90])?; seed.full(376, v_216); seed.full(384, v_217); break 'yield_0 []; }, _ => { return Err(no_match(200, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 239, &[v_8, v_9])?; seed.full(464, v_220); let [v_221]: [G; 1] = [G::from_u64(0)]; let [v_222]: [G; 1] = context.call::<1>(191, 239, &[v_220, v_221])?; seed.u32(596, v_222); let [v_223]: [G; 1] = context.call::<1>(192, 189, &[v_222])?; seed.u32(600, v_223); let [v_224]: [G; 1] = context.call::<1>(193, 242, &[v_223])?; seed.full(472, v_224); let [v_227]: [G; 1] = [G::from_u64(1)]; let [v_228, v_229]: [G; 2] = context.call::<2>(198, 182, &[v_18, v_19, v_32])?; seed.full(480, v_228); seed.full(488, v_229); let [v_230, v_231]: [G; 2] = context.call::<2>(199, 197, &[v_223, v_228, v_229, v_227, v_221])?; seed.full(496, v_230); seed.full(504, v_231); let [v_246]: [G; 1] = context.returned::<1>(215)?; seed.u8(610, v_246); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +fn write_200(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 11] = [G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23]), G::from_u64(seed[24]), G::from_u64(seed[25]), G::from_u64(seed[26]), G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30]), G::from_u64(seed[31])]; row[offsets.auxiliaries + 1] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_30.as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { match v_21.as_canonical_u64() { _ => { let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 12] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(32)]; let [v_34]: [G; 1] = [Bytes2::less_than(&v_32, &v_33)]; row[offsets.auxiliaries + 13] = v_34.as_canonical_u64(); let [v_36]: [G; 1] = [G::from_u64(seed[33])]; row[offsets.auxiliaries + 14] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = [G::from_u64(seed[34]), G::from_u64(seed[35])]; row[offsets.auxiliaries + 15] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 17] = v_39.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[37])]; row[offsets.auxiliaries + 18] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[38])]; row[offsets.auxiliaries + 19] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 20] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[40])]; row[offsets.auxiliaries + 21] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[41])]; row[offsets.auxiliaries + 22] = v_45.as_canonical_u64(); let [v_46, v_47]: [G; 2] = [G::from_u64(seed[42]), G::from_u64(seed[43])]; row[offsets.auxiliaries + 23] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_47.as_canonical_u64(); let [v_57, v_58]: [G; 2] = 'yield_0: { match v_46.as_canonical_u64() { 0u64 => { let [v_49]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 25] = v_49.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_49, v_49]; }, 1u64 => { match v_6.as_canonical_u64() { 0u64 => { let [v_51]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 25] = v_51.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_51, v_51]; }, 1u64 => { let [v_52]: [G; 1] = [G::from_u64(seed[44])]; row[offsets.auxiliaries + 25] = v_52.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[45])]; row[offsets.auxiliaries + 26] = v_54.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[46])]; row[offsets.auxiliaries + 27] = v_56.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(200, v_6)); }, } }, _ => { return Err(no_match(200, v_46)); }, } }; row[offsets.auxiliaries + 28] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 30] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [v_59 - v_27]; let [v_61]: [G; 1] = [G::from_bool(v_60.is_zero())]; row[offsets.auxiliaries + 31] = g_inverse_value(v_60).as_canonical_u64(); row[offsets.auxiliaries + 32] = v_61.as_canonical_u64(); let [v_62]: [G; 1] = [G::from_u64(1)]; let [v_63]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 33] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = [v_63 - v_27]; let [v_65]: [G; 1] = [G::from_bool(v_64.is_zero())]; row[offsets.auxiliaries + 34] = g_inverse_value(v_64).as_canonical_u64(); row[offsets.auxiliaries + 35] = v_65.as_canonical_u64(); let [v_66]: [G; 1] = [G::from_u64(seed[49])]; row[offsets.auxiliaries + 36] = v_66.as_canonical_u64(); let [v_67]: [G; 1] = [v_66 - v_29]; let [v_68]: [G; 1] = [G::from_bool(v_67.is_zero())]; row[offsets.auxiliaries + 37] = g_inverse_value(v_67).as_canonical_u64(); row[offsets.auxiliaries + 38] = v_68.as_canonical_u64(); let [v_69]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 39] = v_69.as_canonical_u64(); let [v_70]: [G; 1] = [v_69 - v_29]; let [v_71]: [G; 1] = [G::from_bool(v_70.is_zero())]; row[offsets.auxiliaries + 40] = g_inverse_value(v_70).as_canonical_u64(); row[offsets.auxiliaries + 41] = v_71.as_canonical_u64(); let [v_72]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 42] = v_72.as_canonical_u64(); let [v_73]: [G; 1] = [v_72 - v_28]; let [v_74]: [G; 1] = [G::from_bool(v_73.is_zero())]; row[offsets.auxiliaries + 43] = g_inverse_value(v_73).as_canonical_u64(); row[offsets.auxiliaries + 44] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 45] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [v_75 - v_28]; let [v_77]: [G; 1] = [G::from_bool(v_76.is_zero())]; row[offsets.auxiliaries + 46] = g_inverse_value(v_76).as_canonical_u64(); row[offsets.auxiliaries + 47] = v_77.as_canonical_u64(); let [v_78, v_79]: [G; 2] = [G::from_u64(seed[53]), G::from_u64(seed[54])]; row[offsets.auxiliaries + 48] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_79.as_canonical_u64(); let [v_80]: [G; 1] = [G::from_u64(0)]; let [v_81]: [G; 1] = [v_78 - v_62]; let [v_82]: [G; 1] = [v_79 - v_80]; let [v_83]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 50] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [g_inverse_value(v_83)]; row[offsets.auxiliaries + 51] = v_84.as_canonical_u64(); let [v_85]: [G; 1] = [v_83 * v_84]; row[offsets.auxiliaries + 52] = v_85.as_canonical_u64(); let [v_86]: [G; 1] = [v_85 - v_62]; let [v_87]: [G; 1] = [v_83 * v_86]; row[offsets.auxiliaries + 53] = v_87.as_canonical_u64(); let [v_88]: [G; 1] = [v_84 * v_86]; row[offsets.auxiliaries + 54] = v_88.as_canonical_u64(); let [v_89]: [G; 1] = [v_18 - v_62]; let [v_90]: [G; 1] = [v_19 - v_80]; let [v_91]: [G; 1] = [v_89 * v_89]; row[offsets.auxiliaries + 55] = v_91.as_canonical_u64(); let [v_92]: [G; 1] = [G::from_u64(7)]; let [v_93]: [G; 1] = [v_90 * v_90]; row[offsets.auxiliaries + 56] = v_93.as_canonical_u64(); let [v_94]: [G; 1] = [v_92 * v_93]; let [v_95]: [G; 1] = [v_91 - v_94]; let [v_96]: [G; 1] = [g_inverse_value(v_95)]; row[offsets.auxiliaries + 57] = v_96.as_canonical_u64(); let [v_97]: [G; 1] = [v_95 * v_96]; row[offsets.auxiliaries + 58] = v_97.as_canonical_u64(); let [v_98]: [G; 1] = [v_97 - v_62]; let [v_99]: [G; 1] = [v_95 * v_98]; row[offsets.auxiliaries + 59] = v_99.as_canonical_u64(); let [v_100]: [G; 1] = [v_96 * v_98]; row[offsets.auxiliaries + 60] = v_100.as_canonical_u64(); let [v_101]: [G; 1] = [v_89 * v_96]; row[offsets.auxiliaries + 61] = v_101.as_canonical_u64(); let [v_102]: [G; 1] = [v_80 - v_90]; let [v_103]: [G; 1] = [v_102 * v_96]; row[offsets.auxiliaries + 62] = v_103.as_canonical_u64(); let [v_104]: [G; 1] = [v_81 * v_101]; row[offsets.auxiliaries + 63] = v_104.as_canonical_u64(); let [v_105]: [G; 1] = [v_82 * v_103]; row[offsets.auxiliaries + 64] = v_105.as_canonical_u64(); let [v_108]: [G; 1] = [v_81 * v_103]; row[offsets.auxiliaries + 65] = v_108.as_canonical_u64(); let [v_109]: [G; 1] = [v_82 * v_101]; row[offsets.auxiliaries + 66] = v_109.as_canonical_u64(); let [v_111]: [G; 1] = [v_18 - v_84]; let [v_112]: [G; 1] = [v_111 * v_111]; row[offsets.auxiliaries + 67] = v_112.as_canonical_u64(); let [v_113]: [G; 1] = [v_112 - v_94]; let [v_114]: [G; 1] = [g_inverse_value(v_113)]; row[offsets.auxiliaries + 68] = v_114.as_canonical_u64(); let [v_115]: [G; 1] = [v_113 * v_114]; row[offsets.auxiliaries + 69] = v_115.as_canonical_u64(); let [v_116]: [G; 1] = [v_115 - v_62]; let [v_117]: [G; 1] = [v_113 * v_116]; row[offsets.auxiliaries + 70] = v_117.as_canonical_u64(); let [v_118]: [G; 1] = [v_114 * v_116]; row[offsets.auxiliaries + 71] = v_118.as_canonical_u64(); let [v_119]: [G; 1] = [v_111 * v_114]; row[offsets.auxiliaries + 72] = v_119.as_canonical_u64(); let [v_120]: [G; 1] = [v_102 * v_114]; row[offsets.auxiliaries + 73] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = [v_81 * v_119]; row[offsets.auxiliaries + 74] = v_121.as_canonical_u64(); let [v_122]: [G; 1] = [v_82 * v_120]; row[offsets.auxiliaries + 75] = v_122.as_canonical_u64(); let [v_123]: [G; 1] = [v_92 * v_122]; let [v_124]: [G; 1] = [v_121 + v_123]; let [v_125]: [G; 1] = [v_81 * v_120]; row[offsets.auxiliaries + 76] = v_125.as_canonical_u64(); let [v_126]: [G; 1] = [v_82 * v_119]; row[offsets.auxiliaries + 77] = v_126.as_canonical_u64(); let [v_127]: [G; 1] = [v_125 + v_126]; let [v_128]: [G; 1] = [v_81 * v_81]; row[offsets.auxiliaries + 78] = v_128.as_canonical_u64(); let [v_129]: [G; 1] = [v_82 * v_82]; row[offsets.auxiliaries + 79] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [v_92 * v_129]; let [v_131]: [G; 1] = [v_128 - v_130]; let [v_132]: [G; 1] = [g_inverse_value(v_131)]; row[offsets.auxiliaries + 80] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [v_131 * v_132]; row[offsets.auxiliaries + 81] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [v_133 - v_62]; let [v_135]: [G; 1] = [v_131 * v_134]; row[offsets.auxiliaries + 82] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [v_132 * v_134]; row[offsets.auxiliaries + 83] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [v_81 * v_132]; row[offsets.auxiliaries + 84] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [v_80 - v_82]; let [v_139]: [G; 1] = [v_138 * v_132]; row[offsets.auxiliaries + 85] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 86] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 87] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 88] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 89] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [G::from_u64(seed[60])]; row[offsets.auxiliaries + 90] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 91] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [G::from_u64(seed[62])]; row[offsets.auxiliaries + 92] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [G::from_u64(seed[63])]; row[offsets.auxiliaries + 93] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [G::from_u64(seed[64])]; row[offsets.auxiliaries + 94] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [G::from_u64(seed[65])]; row[offsets.auxiliaries + 95] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [G::from_u64(seed[66])]; row[offsets.auxiliaries + 96] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [v_149 * v_150]; row[offsets.auxiliaries + 97] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [g_inverse_value(v_151)]; row[offsets.auxiliaries + 98] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [v_151 * v_152]; row[offsets.auxiliaries + 99] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [v_153 - v_62]; let [v_155]: [G; 1] = [v_151 * v_154]; row[offsets.auxiliaries + 100] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [v_152 * v_154]; row[offsets.auxiliaries + 101] = v_156.as_canonical_u64(); let [v_157, v_158]: [G; 2] = [G::from_u64(seed[67]), G::from_u64(seed[68])]; row[offsets.auxiliaries + 102] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [v_37 - v_10]; let [v_160]: [G; 1] = [v_80 - v_80]; let [v_161]: [G; 1] = [v_159 * v_152]; row[offsets.auxiliaries + 104] = v_161.as_canonical_u64(); let [v_162]: [G; 1] = [v_160 * v_80]; let [v_163]: [G; 1] = [v_92 * v_162]; let [v_164]: [G; 1] = [v_161 + v_163]; let [v_165]: [G; 1] = [v_159 * v_80]; let [v_166]: [G; 1] = [v_160 * v_152]; let [v_167]: [G; 1] = [v_165 + v_166]; let [v_168]: [G; 1] = [v_124 * v_164]; row[offsets.auxiliaries + 105] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [v_127 * v_167]; row[offsets.auxiliaries + 106] = v_169.as_canonical_u64(); let [v_172]: [G; 1] = [v_124 * v_167]; row[offsets.auxiliaries + 107] = v_172.as_canonical_u64(); let [v_173]: [G; 1] = [v_127 * v_164]; row[offsets.auxiliaries + 108] = v_173.as_canonical_u64(); let [v_175]: [G; 1] = [v_38 - v_11]; let [v_176]: [G; 1] = [v_175 * v_152]; row[offsets.auxiliaries + 109] = v_176.as_canonical_u64(); let [v_177]: [G; 1] = [v_176 + v_163]; let [v_178]: [G; 1] = [v_175 * v_80]; let [v_179]: [G; 1] = [v_178 + v_166]; let [v_180]: [G; 1] = [v_124 * v_177]; row[offsets.auxiliaries + 110] = v_180.as_canonical_u64(); let [v_181]: [G; 1] = [v_127 * v_179]; row[offsets.auxiliaries + 111] = v_181.as_canonical_u64(); let [v_184]: [G; 1] = [v_124 * v_179]; row[offsets.auxiliaries + 112] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = [v_127 * v_177]; row[offsets.auxiliaries + 113] = v_185.as_canonical_u64(); let [v_187, v_188, v_189, v_190]: [G; 4] = [G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 114] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_190.as_canonical_u64(); let [v_218, v_219]: [G; 2] = 'yield_0: { match v_187.as_canonical_u64() { 1u64 => { let [v_192, v_193]: [G; 2] = [G::from_u64(seed[73]), G::from_u64(seed[74])]; row[offsets.auxiliaries + 118] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_193.as_canonical_u64(); let [v_194, v_195]: [G; 2] = [G::from_u64(seed[75]), G::from_u64(seed[76])]; row[offsets.auxiliaries + 120] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_195.as_canonical_u64(); let [v_200, v_201]: [G; 2] = [G::from_u64(seed[77]), G::from_u64(seed[78])]; row[offsets.auxiliaries + 122] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_201.as_canonical_u64(); let [v_203, v_204]: [G; 2] = [G::from_u64(seed[79]), G::from_u64(seed[80])]; row[offsets.auxiliaries + 124] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_204.as_canonical_u64(); let [v_205, v_206]: [G; 2] = [G::from_u64(seed[81]), G::from_u64(seed[82])]; row[offsets.auxiliaries + 126] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_206.as_canonical_u64(); let [v_211, v_212]: [G; 2] = [G::from_u64(seed[83]), G::from_u64(seed[84])]; row[offsets.auxiliaries + 128] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_212.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 [v_211, v_212]; }, 0u64 => { let [v_214]: [G; 1] = [G::from_u64(seed[73])]; row[offsets.auxiliaries + 118] = v_214.as_canonical_u64(); let [v_216, v_217]: [G; 2] = [G::from_u64(seed[74]), G::from_u64(seed[75])]; row[offsets.auxiliaries + 119] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_217.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_216, v_217]; }, _ => { return Err(no_match(200, v_187)); }, } }; row[offsets.auxiliaries + 130] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_219.as_canonical_u64(); let [v_220]: [G; 1] = [G::from_u64(seed[85])]; row[offsets.auxiliaries + 132] = v_220.as_canonical_u64(); let [v_222]: [G; 1] = [G::from_u64(seed[86])]; row[offsets.auxiliaries + 133] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = [G::from_u64(seed[87])]; row[offsets.auxiliaries + 134] = v_223.as_canonical_u64(); let [v_224]: [G; 1] = [G::from_u64(seed[88])]; row[offsets.auxiliaries + 135] = v_224.as_canonical_u64(); let [v_225]: [G; 1] = [v_224 - v_36]; let [v_226]: [G; 1] = [G::from_bool(v_225.is_zero())]; row[offsets.auxiliaries + 136] = g_inverse_value(v_225).as_canonical_u64(); row[offsets.auxiliaries + 137] = v_226.as_canonical_u64(); let [v_228, v_229]: [G; 2] = [G::from_u64(seed[89]), G::from_u64(seed[90])]; row[offsets.auxiliaries + 138] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_229.as_canonical_u64(); let [v_230, v_231]: [G; 2] = [G::from_u64(seed[91]), G::from_u64(seed[92])]; row[offsets.auxiliaries + 140] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_231.as_canonical_u64(); let [v_232]: [G; 1] = [v_218 * v_137]; row[offsets.auxiliaries + 142] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [G::from_u64(7)]; let [v_234]: [G; 1] = [v_219 * v_139]; row[offsets.auxiliaries + 143] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [v_233 * v_234]; let [v_236]: [G; 1] = [v_232 + v_235]; let [v_237]: [G; 1] = [v_218 * v_139]; row[offsets.auxiliaries + 144] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [v_219 * v_137]; row[offsets.auxiliaries + 145] = v_238.as_canonical_u64(); let [v_239]: [G; 1] = [v_237 + v_238]; let [v_240]: [G; 1] = [v_236 - v_230]; let [v_241]: [G; 1] = [G::from_bool(v_240.is_zero())]; row[offsets.auxiliaries + 146] = g_inverse_value(v_240).as_canonical_u64(); row[offsets.auxiliaries + 147] = v_241.as_canonical_u64(); let [v_242]: [G; 1] = [v_239 - v_231]; let [v_243]: [G; 1] = [G::from_bool(v_242.is_zero())]; row[offsets.auxiliaries + 148] = g_inverse_value(v_242).as_canonical_u64(); row[offsets.auxiliaries + 149] = v_243.as_canonical_u64(); let [v_244]: [G; 1] = [v_241 * v_243]; row[offsets.auxiliaries + 150] = v_244.as_canonical_u64(); let [v_246]: [G; 1] = [G::from_u64(seed[93])]; row[offsets.auxiliaries + 151] = v_246.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(200, v_20)) }, } } + +static SCHEMA_200: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 512, 8, 16, 24, 32, 40, 604, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 605, 516, 152, 520, 160, 524, 168, 176, 184, 192, 528, 606, 607, 200, 208, 216, 532, 536, 224, 540, 544, 608, 232, 240, 548, 552, 248, 256, 264, 272, 280, 288, 296, 304, 312, 556, 560, 564, 568, 572, 576, 580, 584, 588, 320, 328, 336, 344, 609, 352, 360, 592, 368, 376, 384, 392, 400, 408, 416, 424, 432, 440, 448, 456, 464, 596, 600, 472, 480, 488, 496, 504, 610], bytes: 616 }; + +fn pack_217(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); seed[5] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed[6] = v_9.as_canonical_u64(); seed[7] = v_10.as_canonical_u64(); seed[8] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 216, &[v_3, v_10])?; seed[9] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed[10] = v_14.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +fn pack_217_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3, v_4]: [G; 3] = context.load::<3>(0, v_0)?; seed.u8(32, v_2); seed.u32(16, v_3); seed.u32(20, v_4); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = context.load::<3>(1, v_1)?; seed.u8(33, v_5); seed.u32(24, v_6); seed.u32(28, v_7); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_1)?; seed.u8(33, v_9); seed.u32(24, v_10); seed.u32(28, v_11); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 216, &[v_3, v_10])?; seed.u8(34, v_12); let [v_14]: [G; 1] = context.returned::<1>(8)?; seed.u8(35, v_14); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +fn write_217(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4]: [G; 3] = [G::from_u64(seed[3]), G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { let [v_5, v_6, v_7]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_14.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(217, v_9)) }, } }, _ => { Err(no_match(217, v_2)) }, } } + +static SCHEMA_217: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 32, 16, 20, 33, 24, 28, 34, 35], bytes: 40 }; + +fn pack_227(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 226, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 226, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 226, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 226, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 226, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 226, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 226, &[v_6, v_14, v_22])?; seed[23] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed[24] = v_24.as_canonical_u64(); Ok(()) } + +fn pack_227_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let [v_16]: [G; 1] = [G::from_u64(1)]; let [v_17]: [G; 1] = context.call::<1>(1, 226, &[v_0, v_8, v_16])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(2, 226, &[v_1, v_9, v_17])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(3, 226, &[v_2, v_10, v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.call::<1>(4, 226, &[v_3, v_11, v_19])?; seed.full(32, v_20); let [v_21]: [G; 1] = context.call::<1>(5, 226, &[v_4, v_12, v_20])?; seed.full(40, v_21); let [v_22]: [G; 1] = context.call::<1>(6, 226, &[v_5, v_13, v_21])?; seed.full(48, v_22); let [v_23]: [G; 1] = context.call::<1>(7, 226, &[v_6, v_14, v_22])?; seed.full(56, v_23); let [v_24]: [G; 1] = context.returned::<1>(8)?; seed.full(64, v_24); Ok(()) } + +fn write_227(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_17]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 2] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 3] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 7] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 8] = v_24.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_227: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 8, 16, 24, 32, 40, 48, 56, 64], bytes: 88 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::U32LessThan(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3])], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Sub(2, 3), Op::Call(1, vec![0, 4, 5], 1, false), Op::IORead(0, 1, 1), Op::Const(G::from_u64(0)), Op::Store(vec![8, 7, 6])], ctrl: Ctrl::Return(1, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![8]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![8]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Mul(12, 12), Op::AssertEq(vec![13], vec![12], Some("u32_add: carry is not boolean".into()))], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::U8RangeCheck(12, 13), Op::U8RangeCheck(14, 15), Op::Const(G::from_u64(1)), Op::Sub(16, 17), Op::Const(G::from_u64(2)), Op::Sub(16, 19), Op::Mul(18, 20), Op::Mul(16, 21), Op::Const(G::from_u64(0)), Op::AssertEq(vec![22], vec![23], Some("u32_add3: carry is not in {0, 1, 2}".into()))], ctrl: Ctrl::Return(0, vec![12, 13, 14, 15]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 7, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![Op::U8Xor(0, 4), Op::U8Xor(1, 5), Op::U8Xor(2, 6), Op::U8Xor(3, 7)], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 0, 1]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 0]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit7(0, 4), Op::U8XorSplit7(1, 5), Op::U8XorSplit7(2, 6), Op::U8XorSplit7(3, 7), Op::Add(8, 11), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![Op::U8XorSplit4(0, 4), Op::U8XorSplit4(1, 5), Op::U8XorSplit4(2, 6), Op::U8XorSplit4(3, 7), Op::Add(10, 13), Op::Add(12, 15), Op::Add(14, 9), Op::Add(8, 11)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 8), Op::Sub(1, 9), Op::Sub(2, 10), Op::Sub(3, 11), Op::Sub(4, 12), Op::Sub(5, 13), Op::Sub(6, 14), Op::Sub(7, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![24]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![24]) }))) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(255), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(255), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8, 8, 8, 8, 8, 8, 8, 8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(7, 9)], ctrl: Ctrl::Return(1, vec![8, 8, 8, 8, 8, 8, 8, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(6, 9)], ctrl: Ctrl::Return(2, vec![8, 8, 8, 8, 8, 8, 10, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(5, 9)], ctrl: Ctrl::Return(3, vec![8, 8, 8, 8, 8, 10, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(4, 9)], ctrl: Ctrl::Return(4, vec![8, 8, 8, 8, 10, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(3, 9)], ctrl: Ctrl::Return(5, vec![8, 8, 8, 10, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(2, 9)], ctrl: Ctrl::Return(6, vec![8, 8, 10, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(1, 9)], ctrl: Ctrl::Return(7, vec![8, 10, 2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 8)], ctrl: Ctrl::Return(8, vec![9, 1, 2, 3, 4, 5, 6, 7]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 9, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".into())), Op::Const(G::from_u64(256)), Op::Mul(9, 1), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Const(G::from_u64(16777216)), Op::Mul(13, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 6), Op::Add(18, 20), Op::Add(16, 21), Op::Add(14, 22), Op::Add(12, 23), Op::Add(10, 24), Op::Add(0, 25)], ctrl: Ctrl::Return(0, vec![26]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(8, 1), Op::Const(G::from_u64(65536)), Op::Mul(10, 2), Op::Const(G::from_u64(16777216)), Op::Mul(12, 3), Op::Const(G::from_u64(4294967296)), Op::Mul(14, 4), Op::Const(G::from_u64(1099511627776)), Op::Mul(16, 5), Op::Const(G::from_u64(281474976710656)), Op::Mul(18, 6), Op::Const(G::from_u64(72057594037927936)), Op::Mul(20, 7), Op::Add(19, 21), Op::Add(17, 22), Op::Add(15, 23), Op::Add(13, 24), Op::Add(11, 25), Op::Add(9, 26), Op::Add(0, 27)], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1020)), Op::Sub(7, 8), Op::Add(6, 9), Op::Add(5, 10), Op::Add(4, 11), Op::EqZero(12), Op::Add(2, 3), Op::Add(1, 14), Op::Add(0, 15), Op::EqZero(16), Op::Const(G::from_u64(1)), Op::Sub(18, 17), Op::Mul(13, 19), Op::Sub(18, 20)], ctrl: Ctrl::Return(0, vec![21]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(1, 2), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::Const(G::from_u64(256)), Op::Mul(9, 2), Op::Const(G::from_u64(65536)), Op::Mul(11, 3), Op::Const(G::from_u64(16777216)), Op::Mul(13, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(15, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(17, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(19, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(21, 8), Op::Add(20, 22), Op::Add(18, 23), Op::Add(16, 24), Op::Add(14, 25), Op::Add(12, 26), Op::Add(10, 27), Op::Add(1, 28), Op::AssertEq(vec![29], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(8, 30), Op::Add(7, 31), Op::Add(6, 32), Op::Add(5, 33), Op::EqZero(34), Op::Add(3, 4), Op::Add(2, 36), Op::Add(1, 37), Op::EqZero(38), Op::Const(G::from_u64(1)), Op::Sub(40, 39), Op::Mul(35, 41), Op::Sub(40, 42), Op::AssertEq(vec![43], vec![40], None)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGInverse(0), Op::Mul(0, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 3), Op::Mul(0, 4), Op::Const(G::from_u64(0)), Op::AssertEq(vec![5], vec![6], None), Op::Mul(1, 4), Op::AssertEq(vec![7], vec![6], None)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![Op::Add(0, 2), Op::Add(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::Sub(1, 3)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(2, 0), Op::Sub(2, 1)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(5, 6), Op::Add(4, 7), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(9, 10)], ctrl: Ctrl::Return(0, vec![8, 11]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(3, 4), Op::Sub(2, 5), Op::UnconstrainedGInverse(6), Op::Mul(6, 7), Op::Const(G::from_u64(1)), Op::Sub(8, 9), Op::Mul(6, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], None), Op::Mul(7, 10), Op::AssertEq(vec![13], vec![12], None), Op::Mul(0, 7), Op::Sub(12, 1), Op::Mul(15, 7)], ctrl: Ctrl::Return(0, vec![14, 16]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_22() -> Function { + Function { body: Block { ops: vec![Op::Mul(2, 2), Op::Const(G::from_u64(7)), Op::Mul(3, 3), Op::Mul(5, 6), Op::Sub(4, 7), Op::UnconstrainedGInverse(8), Op::Mul(8, 9), Op::Const(G::from_u64(1)), Op::Sub(10, 11), Op::Mul(8, 12), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], None), Op::Mul(9, 12), Op::AssertEq(vec![15], vec![14], None), Op::Mul(2, 9), Op::Sub(14, 3), Op::Mul(17, 9), Op::Mul(0, 16), Op::Mul(1, 18), Op::Mul(5, 20), Op::Add(19, 21), Op::Mul(0, 18), Op::Mul(1, 16), Op::Add(23, 24)], ctrl: Ctrl::Return(0, vec![22, 25]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 13, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_23() -> Function { + Function { body: Block { ops: vec![Op::Sub(0, 2), Op::EqZero(4), Op::Sub(1, 3), Op::EqZero(6), Op::Mul(5, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_24() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(1, vec![4, 6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_25() -> Function { + Function { body: Block { ops: vec![Op::Call(24, vec![0], 2, false), Op::Call(24, vec![2], 2, false), Op::Call(24, vec![4], 2, false), Op::Call(24, vec![6], 2, false), Op::Call(24, vec![8], 2, false), Op::Call(24, vec![10], 2, false), Op::Call(24, vec![12], 2, false), Op::Call(24, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_26() -> Function { + Function { body: Block { ops: vec![Op::Call(25, vec![0], 9, false), Op::Call(12, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_27() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 1), Op::Const(G::from_u64(1)), Op::Add(0, 3)], ctrl: Ctrl::Return(0, vec![2, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_28() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IORead(1, 0, 8), Op::Const(G::from_u64(8)), Op::Add(0, 10)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_29() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(12, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(0, vec![10, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 11, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_30() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![9], 9, true), Op::Const(G::from_u64(256)), Op::Mul(19, 2), Op::Const(G::from_u64(65536)), Op::Mul(21, 3), Op::Const(G::from_u64(16777216)), Op::Mul(23, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(25, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(27, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(29, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 8), Op::Add(30, 32), Op::Add(28, 33), Op::Add(26, 34), Op::Add(24, 35), Op::Add(22, 36), Op::Add(20, 37), Op::Add(1, 38), Op::Mul(19, 11), Op::Mul(21, 12), Op::Mul(23, 13), Op::Mul(25, 14), Op::Mul(27, 15), Op::Mul(29, 16), Op::Mul(31, 17), Op::Add(45, 46), Op::Add(44, 47), Op::Add(43, 48), Op::Add(42, 49), Op::Add(41, 50), Op::Add(40, 51), Op::Add(10, 52)], ctrl: Ctrl::Return(0, vec![39, 53, 18]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 19, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_31() -> Function { + Function { body: Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![9], 9, true), Op::Call(28, vec![18], 9, true), Op::Call(28, vec![27], 9, true)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_32() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_33() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(27, vec![0], 2, true), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(33, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_34() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(35, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_35() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(35, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_36() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(37, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_37() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![10], 9, true), Op::Const(G::from_u64(256)), Op::Mul(20, 3), Op::Const(G::from_u64(65536)), Op::Mul(22, 4), Op::Const(G::from_u64(16777216)), Op::Mul(24, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(26, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(28, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(30, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(32, 9), Op::Add(31, 33), Op::Add(29, 34), Op::Add(27, 35), Op::Add(25, 36), Op::Add(23, 37), Op::Add(21, 38), Op::Add(2, 39), Op::Mul(20, 12), Op::Mul(22, 13), Op::Mul(24, 14), Op::Mul(26, 15), Op::Mul(28, 16), Op::Mul(30, 17), Op::Mul(32, 18), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(11, 53), Op::Const(G::from_u64(1)), Op::Sub(1, 55), Op::Call(37, vec![19, 56], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![59, 40, 54, 57])], ctrl: Ctrl::Return(1, vec![60, 58]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_38() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(39, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_39() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(28, vec![0], 9, true), Op::Call(28, vec![10], 9, true), Op::Call(28, vec![19], 9, true), Op::Call(28, vec![28], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(39, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_40() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(41, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_41() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(34, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(41, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_42() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(43, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_43() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(41, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(43, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_44() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(45, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_45() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(36, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(45, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_46() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(47, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_47() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(44, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(47, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_48() -> Function { + Function { body: Block { ops: vec![Op::Call(38, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_49() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(50, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_50() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(38, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(50, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_51() -> Function { + Function { body: Block { ops: vec![Op::Call(38, vec![0], 2, false), Op::Call(38, vec![2], 2, false), Op::Call(38, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_52() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(43, vec![2, 1], 2, false), Op::Call(38, vec![4], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_53() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(54, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_54() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(43, vec![3, 2], 2, false), Op::Call(38, vec![5], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(54, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 4, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_55() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 2, true), Op::Call(29, vec![2], 2, false), Op::Call(45, vec![4, 3], 2, false), Op::Call(38, vec![6], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 7, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_56() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(57, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_57() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(27, vec![0], 2, true), Op::Call(29, vec![3], 2, false), Op::Call(45, vec![5, 4], 2, false), Op::Call(38, vec![7], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 10), Op::Call(57, vec![9, 11], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 2, 6, 8, 12])], ctrl: Ctrl::Return(1, vec![15, 13]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_58() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(50, vec![2, 1], 2, false), Op::Call(34, vec![4], 2, false), Op::Call(29, vec![6], 2, false), Op::Call(54, vec![8, 7], 2, false), Op::Call(29, vec![10], 2, false), Op::Call(57, vec![12, 11], 2, false), Op::Call(36, vec![14], 2, false), Op::Call(28, vec![16], 9, true)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 26, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_59() -> Function { + Function { body: Block { ops: vec![Op::Call(27, vec![0], 2, true)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(46, vec![2], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5, 3, 4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_60() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![2, 1], 2, false), Op::Call(38, vec![4], 2, false), Op::Call(38, vec![6], 2, false), Op::Call(38, vec![8], 2, false), Op::Call(36, vec![10], 2, false), Op::Call(29, vec![12], 2, false), Op::Call(33, vec![14, 13], 2, false), Op::Call(29, vec![16], 2, false), Op::Call(50, vec![18, 17], 2, false), Op::Call(34, vec![20], 2, false), Op::Call(29, vec![22], 2, false), Op::Call(54, vec![24, 23], 2, false), Op::Call(29, vec![26], 2, false), Op::Call(57, vec![28, 27], 2, false), Op::Call(36, vec![30], 2, false), Op::Call(28, vec![32], 9, true), Op::Call(46, vec![41], 2, false), Op::Call(59, vec![43], 3, false), Op::Call(46, vec![46], 2, false), Op::Call(46, vec![48], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 7, 9, 11, 15, 19, 21, 25, 29, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 44, 45, 47, 49, 50]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_61() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![2, 1], 2, false), Op::Call(38, vec![4], 2, false), Op::Call(29, vec![6], 2, false), Op::Call(33, vec![8, 7], 2, false), Op::Call(29, vec![10], 2, false), Op::Call(41, vec![12, 11], 2, false)], ctrl: Ctrl::Return(0, vec![3, 5, 9, 13, 14]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_62() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(63, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_63() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(33, vec![3, 2], 2, false), Op::Call(38, vec![5], 2, false), Op::Call(29, vec![7], 2, false), Op::Call(33, vec![9, 8], 2, false), Op::Call(29, vec![11], 2, false), Op::Call(41, vec![13, 12], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 16), Op::Call(63, vec![15, 17], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![20, 4, 6, 10, 14, 18])], ctrl: Ctrl::Return(1, vec![21, 19]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_64() -> Function { + Function { body: Block { ops: vec![Op::Call(34, vec![0], 2, false), Op::Call(28, vec![2], 9, true)], ctrl: Ctrl::Return(0, vec![1, 3, 4, 5, 6, 7, 8, 9, 10, 11]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 12, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_65() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(66, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_66() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(34, vec![0], 2, false), Op::Call(28, vec![3], 9, true), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Call(66, vec![12, 14], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![17, 2, 4, 5, 6, 7, 8, 9, 10, 11, 15])], ctrl: Ctrl::Return(1, vec![18, 16]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_67() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(68, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_68() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(60, vec![0], 25, false), Op::Const(G::from_u64(1)), Op::Sub(1, 27), Op::Call(68, vec![26, 28], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![31, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 29])], ctrl: Ctrl::Return(1, vec![32, 30]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_69() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![0], 2, false), Op::Call(63, vec![2, 1], 2, false), Op::Call(29, vec![4], 2, false), Op::Call(66, vec![6, 5], 2, false), Op::Call(29, vec![8], 2, false), Op::Call(68, vec![10, 9], 2, false)], ctrl: Ctrl::Return(0, vec![3, 7, 11, 12]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 13, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_70() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Const(G::from_u64(65536)), Op::Mul(6, 2), Op::Const(G::from_u64(16777216)), Op::Mul(8, 3), Op::Add(7, 9), Op::Add(5, 10), Op::Add(0, 11)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_71() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Const(G::from_u64(65536)), Op::Mul(34, 2), Op::Const(G::from_u64(16777216)), Op::Mul(36, 3), Op::Add(35, 37), Op::Add(33, 38), Op::Add(0, 39), Op::Mul(32, 5), Op::Mul(34, 6), Op::Mul(36, 7), Op::Add(42, 43), Op::Add(41, 44), Op::Add(4, 45), Op::Mul(32, 9), Op::Mul(34, 10), Op::Mul(36, 11), Op::Add(48, 49), Op::Add(47, 50), Op::Add(8, 51), Op::Mul(32, 13), Op::Mul(34, 14), Op::Mul(36, 15), Op::Add(54, 55), Op::Add(53, 56), Op::Add(12, 57), Op::Mul(32, 17), Op::Mul(34, 18), Op::Mul(36, 19), Op::Add(60, 61), Op::Add(59, 62), Op::Add(16, 63), Op::Mul(32, 21), Op::Mul(34, 22), Op::Mul(36, 23), Op::Add(66, 67), Op::Add(65, 68), Op::Add(20, 69), Op::Mul(32, 25), Op::Mul(34, 26), Op::Mul(36, 27), Op::Add(72, 73), Op::Add(71, 74), Op::Add(24, 75), Op::Mul(32, 29), Op::Mul(34, 30), Op::Mul(36, 31), Op::Add(78, 79), Op::Add(77, 80), Op::Add(28, 81)], ctrl: Ctrl::Return(0, vec![40, 46, 52, 58, 64, 70, 76, 82]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_72() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(75, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(74, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_73() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![68, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(73, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68], 34, false)], ctrl: Ctrl::Match(69, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![103, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 102]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(34, 102)], ctrl: Ctrl::Match(136, [(G::from_u64(1), Block { ops: vec![Op::Mul(104, 33), Op::Add(103, 170), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![172, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 174, 175, 176, 177, 178, 179, 174, 180, 181, 182, 183, 184, 185, 186, 187, 188, 172, 172, 172, 172, 172, 172, 172, 172, 173, 172, 172, 172, 171, 172, 172, 172, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![172, 102, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220])], ctrl: Ctrl::Return(2, vec![172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 221]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![170, 105, 106, 107, 108, 109, 110, 105, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 172, 173, 174, 175, 176, 177, 172, 178, 179, 180, 181, 182, 183, 184, 185, 186, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 170, 170, 103, 170, 170, 170, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 32, false), Op::Store(vec![170, 102, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218])], ctrl: Ctrl::Return(3, vec![170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 219]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_74() -> Function { + Function { body: Block { ops: vec![Op::Load(34, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(34, 2)], ctrl: Ctrl::Match(35, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(73, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 69], 34, false)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Call(74, vec![103], 32, false)], ctrl: Ctrl::Return(1, vec![104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![104, 103, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]), Op::Call(74, vec![105], 32, false)], ctrl: Ctrl::Return(2, vec![106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 137, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_75() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(78, vec![1, 2, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![10, 8, 1])], ctrl: Ctrl::Match(2, [(G::from_u64(63), Block { ops: vec![Op::Call(79, vec![9, 11, 3, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 12), Op::Add(3, 12), Op::Call(75, vec![9, 11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![15]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_76() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 21)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 27)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 36)], ctrl: Ctrl::Match(37, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 39)], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 45)], ctrl: Ctrl::Match(46, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 48)], ctrl: Ctrl::Match(49, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 51)], ctrl: Ctrl::Match(52, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 54)], ctrl: Ctrl::Match(55, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 60)], ctrl: Ctrl::Match(61, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 63)], ctrl: Ctrl::Match(64, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 66)], ctrl: Ctrl::Match(67, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 69)], ctrl: Ctrl::Match(70, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 72)], ctrl: Ctrl::Match(73, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 75)], ctrl: Ctrl::Match(76, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 78)], ctrl: Ctrl::Match(79, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 81)], ctrl: Ctrl::Match(82, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 84)], ctrl: Ctrl::Match(85, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 87)], ctrl: Ctrl::Match(88, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 90)], ctrl: Ctrl::Match(91, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 93)], ctrl: Ctrl::Match(94, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 96)], ctrl: Ctrl::Match(97, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 99)], ctrl: Ctrl::Match(100, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 102)], ctrl: Ctrl::Match(103, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 105)], ctrl: Ctrl::Match(106, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 108)], ctrl: Ctrl::Match(109, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 111)], ctrl: Ctrl::Match(112, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 114)], ctrl: Ctrl::Match(115, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 117)], ctrl: Ctrl::Match(118, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 120)], ctrl: Ctrl::Match(121, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 123)], ctrl: Ctrl::Match(124, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 126)], ctrl: Ctrl::Match(127, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 129)], ctrl: Ctrl::Match(130, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 132)], ctrl: Ctrl::Match(133, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 135)], ctrl: Ctrl::Match(136, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 138)], ctrl: Ctrl::Match(139, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 141)], ctrl: Ctrl::Match(142, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 144)], ctrl: Ctrl::Match(145, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 147)], ctrl: Ctrl::Match(148, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 150)], ctrl: Ctrl::Match(151, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 153)], ctrl: Ctrl::Match(154, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 156)], ctrl: Ctrl::Match(157, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 159)], ctrl: Ctrl::Match(160, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 162)], ctrl: Ctrl::Match(163, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 165)], ctrl: Ctrl::Match(166, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 168)], ctrl: Ctrl::Match(169, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 171)], ctrl: Ctrl::Match(172, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 174)], ctrl: Ctrl::Match(175, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 177)], ctrl: Ctrl::Match(178, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 180)], ctrl: Ctrl::Match(181, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 183)], ctrl: Ctrl::Match(184, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 186)], ctrl: Ctrl::Match(187, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 189)], ctrl: Ctrl::Match(190, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![191, 188, 185, 182, 179, 176, 173, 170, 167, 164, 161, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_77() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 0]), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(77, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_78() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Add(6, 7), Op::Add(8, 17), Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![51, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 60, 61, 62, 63, 64, 65, 60, 66, 67, 68, 69, 70, 71, 72, 73, 74, 52, 53, 54, 55, 56, 57, 58, 59, 51, 51, 51, 51, 18, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51], 32, false), Op::Store(vec![51, 5, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106])], ctrl: Ctrl::Return(0, vec![107]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Load(32, 4), Op::Store(vec![9, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41])], ctrl: Ctrl::Return(9, vec![42]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(8, 3), Op::Call(2, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Sub(2, 1), Op::EqZero(19), Op::Mul(20, 6), Op::Add(18, 21), Op::Add(7, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(77, vec![0, 25], 1, false), Op::Call(76, vec![26], 64, false), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![138, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 123, 129, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 14, 15, 16, 1, 138, 138, 138, 23, 138, 138, 138, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90], 32, false), Op::Store(vec![138, 5, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170])], ctrl: Ctrl::Return(10, vec![171]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_79() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(76, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(249, vec![0], 1, false), Op::Load(8, 3), Op::Call(2, vec![74, 75, 76, 77, 78, 79, 80, 81], 1, false), Op::Mul(73, 82), Op::Mul(8, 83), Op::Add(84, 7), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(0)), Op::Call(83, vec![150, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 74, 75, 76, 77, 78, 79, 80, 81, 149, 150, 150, 150, 85, 150, 150, 150, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Store(vec![150, 5, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182]), Op::Const(G::from_u64(1)), Op::Store(vec![184, 184, 184]), Op::Call(11, vec![74, 75, 76, 77, 78, 79, 80, 81], 8, false), Op::Store(vec![186, 187, 188, 189, 190, 191, 192, 193]), Op::Store(vec![86, 87, 88, 89, 90, 91, 86, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116]), Op::Call(75, vec![0, 185, 150, 150, 194, 195, 183], 1, false)], ctrl: Ctrl::Return(0, vec![196]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(249, vec![0], 1, false), Op::Mul(73, 7), Op::Call(249, vec![0], 1, false), Op::Load(8, 3), Op::Call(2, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(84, 8), Op::Mul(75, 85), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(86, 90), Op::Add(74, 91), Op::Load(32, 4), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![141, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131, 126, 132, 133, 134, 135, 136, 137, 138, 139, 140, 76, 77, 78, 79, 80, 81, 82, 83, 125, 141, 141, 141, 92, 141, 141, 141, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], 32, false), Op::Const(G::from_u64(1)), Op::Store(vec![174, 174, 174]), Op::Add(2, 174), Op::Store(vec![142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173]), Op::Call(75, vec![0, 175, 141, 176, 3, 177, 5], 1, false)], ctrl: Ctrl::Return(1, vec![178]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_80() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![16, 17, 18, 19]), Op::U8RangeCheck(24, 25), Op::U8RangeCheck(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Const(G::from_u64(2)), Op::Sub(28, 31), Op::Mul(30, 32), Op::Mul(28, 33), Op::Const(G::from_u64(0)), Op::AssertEq(vec![34], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(12, 24), Op::U8Xor(13, 25), Op::U8Xor(14, 26), Op::U8Xor(15, 27), Op::UnconstrainedU32Add(vec![8, 9, 10, 11], vec![38, 39, 36, 37]), Op::U8RangeCheck(40, 41), Op::U8RangeCheck(42, 43), Op::Mul(44, 44), Op::AssertEq(vec![45], vec![44], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(4, 40), Op::U8XorSplit4(5, 41), Op::U8XorSplit4(6, 42), Op::U8XorSplit4(7, 43), Op::Add(48, 51), Op::Add(50, 53), Op::Add(52, 47), Op::Add(46, 49), Op::UnconstrainedU32Add3(vec![24, 25, 26, 27], vec![54, 55, 56, 57], vec![20, 21, 22, 23]), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::Sub(62, 29), Op::Sub(62, 31), Op::Mul(63, 64), Op::Mul(62, 65), Op::AssertEq(vec![66], vec![35], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(38, 58), Op::U8Xor(39, 59), Op::U8Xor(36, 60), Op::U8Xor(37, 61), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![68, 69, 70, 67]), Op::U8RangeCheck(71, 72), Op::U8RangeCheck(73, 74), Op::Mul(75, 75), Op::AssertEq(vec![76], vec![75], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(54, 71), Op::U8XorSplit7(55, 72), Op::U8XorSplit7(56, 73), Op::U8XorSplit7(57, 74), Op::Add(77, 80), Op::Add(79, 82), Op::Add(81, 84), Op::Add(83, 78)], ctrl: Ctrl::Return(0, vec![58, 59, 60, 61, 85, 86, 87, 88, 71, 72, 73, 74, 68, 69, 70, 67]) }, layout: FunctionLayout { input_size: 24, selectors: 1, auxiliaries: 47, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_81() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![16, 17, 18, 19], vec![64, 65, 66, 67]), Op::U8RangeCheck(128, 129), Op::U8RangeCheck(130, 131), Op::Const(G::from_u64(1)), Op::Sub(132, 133), Op::Const(G::from_u64(2)), Op::Sub(132, 135), Op::Mul(134, 136), Op::Mul(132, 137), Op::Const(G::from_u64(0)), Op::AssertEq(vec![138], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(48, 128), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::UnconstrainedU32Add(vec![32, 33, 34, 35], vec![142, 143, 140, 141]), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::Mul(148, 148), Op::AssertEq(vec![149], vec![148], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(16, 144), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::Add(152, 155), Op::Add(154, 157), Op::Add(156, 151), Op::Add(150, 153), Op::UnconstrainedU32Add3(vec![128, 129, 130, 131], vec![158, 159, 160, 161], vec![68, 69, 70, 71]), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::Sub(166, 133), Op::Sub(166, 135), Op::Mul(167, 168), Op::Mul(166, 169), Op::AssertEq(vec![170], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(142, 162), Op::U8Xor(143, 163), Op::U8Xor(140, 164), Op::U8Xor(141, 165), Op::UnconstrainedU32Add(vec![144, 145, 146, 147], vec![172, 173, 174, 171]), Op::U8RangeCheck(175, 176), Op::U8RangeCheck(177, 178), Op::Mul(179, 179), Op::AssertEq(vec![180], vec![179], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(158, 175), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::Add(181, 184), Op::Add(183, 186), Op::Add(185, 188), Op::Add(187, 182), Op::UnconstrainedU32Add3(vec![4, 5, 6, 7], vec![20, 21, 22, 23], vec![72, 73, 74, 75]), Op::U8RangeCheck(193, 194), Op::U8RangeCheck(195, 196), Op::Sub(197, 133), Op::Sub(197, 135), Op::Mul(198, 199), Op::Mul(197, 200), Op::AssertEq(vec![201], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(52, 193), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::UnconstrainedU32Add(vec![36, 37, 38, 39], vec![204, 205, 202, 203]), Op::U8RangeCheck(206, 207), Op::U8RangeCheck(208, 209), Op::Mul(210, 210), Op::AssertEq(vec![211], vec![210], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(20, 206), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::Add(214, 217), Op::Add(216, 219), Op::Add(218, 213), Op::Add(212, 215), Op::UnconstrainedU32Add3(vec![193, 194, 195, 196], vec![220, 221, 222, 223], vec![76, 77, 78, 79]), Op::U8RangeCheck(224, 225), Op::U8RangeCheck(226, 227), Op::Sub(228, 133), Op::Sub(228, 135), Op::Mul(229, 230), Op::Mul(228, 231), Op::AssertEq(vec![232], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(204, 224), Op::U8Xor(205, 225), Op::U8Xor(202, 226), Op::U8Xor(203, 227), Op::UnconstrainedU32Add(vec![206, 207, 208, 209], vec![234, 235, 236, 233]), Op::U8RangeCheck(237, 238), Op::U8RangeCheck(239, 240), Op::Mul(241, 241), Op::AssertEq(vec![242], vec![241], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(220, 237), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::Add(243, 246), Op::Add(245, 248), Op::Add(247, 250), Op::Add(249, 244), Op::UnconstrainedU32Add3(vec![8, 9, 10, 11], vec![24, 25, 26, 27], vec![80, 81, 82, 83]), Op::U8RangeCheck(255, 256), Op::U8RangeCheck(257, 258), Op::Sub(259, 133), Op::Sub(259, 135), Op::Mul(260, 261), Op::Mul(259, 262), Op::AssertEq(vec![263], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(56, 255), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::UnconstrainedU32Add(vec![40, 41, 42, 43], vec![266, 267, 264, 265]), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::Mul(272, 272), Op::AssertEq(vec![273], vec![272], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(24, 268), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::Add(276, 279), Op::Add(278, 281), Op::Add(280, 275), Op::Add(274, 277), Op::UnconstrainedU32Add3(vec![255, 256, 257, 258], vec![282, 283, 284, 285], vec![84, 85, 86, 87]), Op::U8RangeCheck(286, 287), Op::U8RangeCheck(288, 289), Op::Sub(290, 133), Op::Sub(290, 135), Op::Mul(291, 292), Op::Mul(290, 293), Op::AssertEq(vec![294], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(266, 286), Op::U8Xor(267, 287), Op::U8Xor(264, 288), Op::U8Xor(265, 289), Op::UnconstrainedU32Add(vec![268, 269, 270, 271], vec![296, 297, 298, 295]), Op::U8RangeCheck(299, 300), Op::U8RangeCheck(301, 302), Op::Mul(303, 303), Op::AssertEq(vec![304], vec![303], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(282, 299), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::Add(305, 308), Op::Add(307, 310), Op::Add(309, 312), Op::Add(311, 306), Op::UnconstrainedU32Add3(vec![12, 13, 14, 15], vec![28, 29, 30, 31], vec![88, 89, 90, 91]), Op::U8RangeCheck(317, 318), Op::U8RangeCheck(319, 320), Op::Sub(321, 133), Op::Sub(321, 135), Op::Mul(322, 323), Op::Mul(321, 324), Op::AssertEq(vec![325], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(60, 317), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::UnconstrainedU32Add(vec![44, 45, 46, 47], vec![328, 329, 326, 327]), Op::U8RangeCheck(330, 331), Op::U8RangeCheck(332, 333), Op::Mul(334, 334), Op::AssertEq(vec![335], vec![334], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(28, 330), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::Add(338, 341), Op::Add(340, 343), Op::Add(342, 337), Op::Add(336, 339), Op::UnconstrainedU32Add3(vec![317, 318, 319, 320], vec![344, 345, 346, 347], vec![92, 93, 94, 95]), Op::U8RangeCheck(348, 349), Op::U8RangeCheck(350, 351), Op::Sub(352, 133), Op::Sub(352, 135), Op::Mul(353, 354), Op::Mul(352, 355), Op::AssertEq(vec![356], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(328, 348), Op::U8Xor(329, 349), Op::U8Xor(326, 350), Op::U8Xor(327, 351), Op::UnconstrainedU32Add(vec![330, 331, 332, 333], vec![358, 359, 360, 357]), Op::U8RangeCheck(361, 362), Op::U8RangeCheck(363, 364), Op::Mul(365, 365), Op::AssertEq(vec![366], vec![365], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(344, 361), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::Add(367, 370), Op::Add(369, 372), Op::Add(371, 374), Op::Add(373, 368), Op::UnconstrainedU32Add3(vec![162, 163, 164, 165], vec![251, 252, 253, 254], vec![96, 97, 98, 99]), Op::U8RangeCheck(379, 380), Op::U8RangeCheck(381, 382), Op::Sub(383, 133), Op::Sub(383, 135), Op::Mul(384, 385), Op::Mul(383, 386), Op::AssertEq(vec![387], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(358, 379), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(357, 382), Op::UnconstrainedU32Add(vec![299, 300, 301, 302], vec![390, 391, 388, 389]), Op::U8RangeCheck(392, 393), Op::U8RangeCheck(394, 395), Op::Mul(396, 396), Op::AssertEq(vec![397], vec![396], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(251, 392), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::Add(400, 403), Op::Add(402, 405), Op::Add(404, 399), Op::Add(398, 401), Op::UnconstrainedU32Add3(vec![379, 380, 381, 382], vec![406, 407, 408, 409], vec![100, 101, 102, 103]), Op::U8RangeCheck(410, 411), Op::U8RangeCheck(412, 413), Op::Sub(414, 133), Op::Sub(414, 135), Op::Mul(415, 416), Op::Mul(414, 417), Op::AssertEq(vec![418], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(390, 410), Op::U8Xor(391, 411), Op::U8Xor(388, 412), Op::U8Xor(389, 413), Op::UnconstrainedU32Add(vec![392, 393, 394, 395], vec![420, 421, 422, 419]), Op::U8RangeCheck(423, 424), Op::U8RangeCheck(425, 426), Op::Mul(427, 427), Op::AssertEq(vec![428], vec![427], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(406, 423), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::Add(429, 432), Op::Add(431, 434), Op::Add(433, 436), Op::Add(435, 430), Op::UnconstrainedU32Add3(vec![224, 225, 226, 227], vec![313, 314, 315, 316], vec![104, 105, 106, 107]), Op::U8RangeCheck(441, 442), Op::U8RangeCheck(443, 444), Op::Sub(445, 133), Op::Sub(445, 135), Op::Mul(446, 447), Op::Mul(445, 448), Op::AssertEq(vec![449], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(172, 441), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(171, 444), Op::UnconstrainedU32Add(vec![361, 362, 363, 364], vec![452, 453, 450, 451]), Op::U8RangeCheck(454, 455), Op::U8RangeCheck(456, 457), Op::Mul(458, 458), Op::AssertEq(vec![459], vec![458], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(313, 454), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::Add(462, 465), Op::Add(464, 467), Op::Add(466, 461), Op::Add(460, 463), Op::UnconstrainedU32Add3(vec![441, 442, 443, 444], vec![468, 469, 470, 471], vec![108, 109, 110, 111]), Op::U8RangeCheck(472, 473), Op::U8RangeCheck(474, 475), Op::Sub(476, 133), Op::Sub(476, 135), Op::Mul(477, 478), Op::Mul(476, 479), Op::AssertEq(vec![480], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(452, 472), Op::U8Xor(453, 473), Op::U8Xor(450, 474), Op::U8Xor(451, 475), Op::UnconstrainedU32Add(vec![454, 455, 456, 457], vec![482, 483, 484, 481]), Op::U8RangeCheck(485, 486), Op::U8RangeCheck(487, 488), Op::Mul(489, 489), Op::AssertEq(vec![490], vec![489], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(468, 485), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::Add(491, 494), Op::Add(493, 496), Op::Add(495, 498), Op::Add(497, 492), Op::UnconstrainedU32Add3(vec![286, 287, 288, 289], vec![375, 376, 377, 378], vec![112, 113, 114, 115]), Op::U8RangeCheck(503, 504), Op::U8RangeCheck(505, 506), Op::Sub(507, 133), Op::Sub(507, 135), Op::Mul(508, 509), Op::Mul(507, 510), Op::AssertEq(vec![511], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(234, 503), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(233, 506), Op::UnconstrainedU32Add(vec![175, 176, 177, 178], vec![514, 515, 512, 513]), Op::U8RangeCheck(516, 517), Op::U8RangeCheck(518, 519), Op::Mul(520, 520), Op::AssertEq(vec![521], vec![520], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(375, 516), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::Add(524, 527), Op::Add(526, 529), Op::Add(528, 523), Op::Add(522, 525), Op::UnconstrainedU32Add3(vec![503, 504, 505, 506], vec![530, 531, 532, 533], vec![116, 117, 118, 119]), Op::U8RangeCheck(534, 535), Op::U8RangeCheck(536, 537), Op::Sub(538, 133), Op::Sub(538, 135), Op::Mul(539, 540), Op::Mul(538, 541), Op::AssertEq(vec![542], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(514, 534), Op::U8Xor(515, 535), Op::U8Xor(512, 536), Op::U8Xor(513, 537), Op::UnconstrainedU32Add(vec![516, 517, 518, 519], vec![544, 545, 546, 543]), Op::U8RangeCheck(547, 548), Op::U8RangeCheck(549, 550), Op::Mul(551, 551), Op::AssertEq(vec![552], vec![551], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(530, 547), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::Add(553, 556), Op::Add(555, 558), Op::Add(557, 560), Op::Add(559, 554), Op::UnconstrainedU32Add3(vec![348, 349, 350, 351], vec![189, 190, 191, 192], vec![120, 121, 122, 123]), Op::U8RangeCheck(565, 566), Op::U8RangeCheck(567, 568), Op::Sub(569, 133), Op::Sub(569, 135), Op::Mul(570, 571), Op::Mul(569, 572), Op::AssertEq(vec![573], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(296, 565), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(295, 568), Op::UnconstrainedU32Add(vec![237, 238, 239, 240], vec![576, 577, 574, 575]), Op::U8RangeCheck(578, 579), Op::U8RangeCheck(580, 581), Op::Mul(582, 582), Op::AssertEq(vec![583], vec![582], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(189, 578), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::Add(586, 589), Op::Add(588, 591), Op::Add(590, 585), Op::Add(584, 587), Op::UnconstrainedU32Add3(vec![565, 566, 567, 568], vec![592, 593, 594, 595], vec![124, 125, 126, 127]), Op::U8RangeCheck(596, 597), Op::U8RangeCheck(598, 599), Op::Sub(600, 133), Op::Sub(600, 135), Op::Mul(601, 602), Op::Mul(600, 603), Op::AssertEq(vec![604], vec![139], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(576, 596), Op::U8Xor(577, 597), Op::U8Xor(574, 598), Op::U8Xor(575, 599), Op::UnconstrainedU32Add(vec![578, 579, 580, 581], vec![606, 607, 608, 605]), Op::U8RangeCheck(609, 610), Op::U8RangeCheck(611, 612), Op::Mul(613, 613), Op::AssertEq(vec![614], vec![613], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(592, 609), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::Add(615, 618), Op::Add(617, 620), Op::Add(619, 622), Op::Add(621, 616)], ctrl: Ctrl::Return(0, vec![410, 411, 412, 413, 472, 473, 474, 475, 534, 535, 536, 537, 596, 597, 598, 599, 623, 624, 625, 626, 437, 438, 439, 440, 499, 500, 501, 502, 561, 562, 563, 564, 547, 548, 549, 550, 609, 610, 611, 612, 423, 424, 425, 426, 485, 486, 487, 488, 482, 483, 484, 481, 544, 545, 546, 543, 606, 607, 608, 605, 420, 421, 422, 419, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]) }, layout: FunctionLayout { input_size: 128, selectors: 1, auxiliaries: 369, lookups: 193 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_82() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![121, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 106, 107, 108, 109, 110, 111, 106, 112, 113, 114, 115, 116, 117, 118, 119, 120, 96, 97, 98, 99, 100, 101, 102, 103, 104, 121, 121, 121, 105, 121, 121, 121, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], 32, false)], ctrl: Ctrl::Return(0, vec![122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153]) }, layout: FunctionLayout { input_size: 106, selectors: 1, auxiliaries: 33, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_83() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(83, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_84() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_85() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false)], ctrl: Ctrl::Return(0, vec![1, 2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_86() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6)], ctrl: Ctrl::Return(0, vec![7, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_87() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Const(G::from_u64(256)), Op::Mul(5, 3), Op::Add(1, 6), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7, 1, 3, 8, 8, 8, 8, 8, 8, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_88() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Call(84, vec![4], 2, false), Op::Call(84, vec![6], 2, false), Op::Const(G::from_u64(256)), Op::Mul(9, 3), Op::Const(G::from_u64(65536)), Op::Mul(11, 5), Op::Const(G::from_u64(16777216)), Op::Mul(13, 7), Op::Add(12, 14), Op::Add(10, 15), Op::Add(1, 16), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![17, 1, 3, 5, 7, 18, 18, 18, 18, 8]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_89() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false), Op::Call(84, vec![2], 2, false), Op::Call(84, vec![4], 2, false), Op::Call(84, vec![6], 2, false), Op::Call(84, vec![8], 2, false), Op::Call(84, vec![10], 2, false), Op::Call(84, vec![12], 2, false), Op::Call(84, vec![14], 2, false)], ctrl: Ctrl::Return(0, vec![1, 3, 5, 7, 9, 11, 13, 15, 16]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 17, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_90() -> Function { + Function { body: Block { ops: vec![Op::Call(89, vec![0], 9, false), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Const(G::from_u64(65536)), Op::Mul(12, 3), Op::Const(G::from_u64(16777216)), Op::Mul(14, 4), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 5), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 6), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 7), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 8), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(1, 29)], ctrl: Ctrl::Return(0, vec![30, 9]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_91() -> Function { + Function { body: Block { ops: vec![Op::Call(89, vec![0], 9, false), Op::Call(89, vec![9], 9, false), Op::Call(89, vec![18], 9, false), Op::Call(89, vec![27], 9, false)], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 37, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_92() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(89, vec![0], 9, false), Op::Call(89, vec![10], 9, false), Op::Call(89, vec![19], 9, false), Op::Call(89, vec![28], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(92, vec![37, 39], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36]), Op::Store(vec![42, 43, 40])], ctrl: Ctrl::Return(1, vec![44, 41]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 42, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_93() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3, 3, 3, 3])], ctrl: Ctrl::Return(0, vec![4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(85, vec![0], 2, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(90, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 5, 12, 12, 10])], ctrl: Ctrl::Return(2, vec![13, 11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(85, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 13, 5, 12, 12, 10])], ctrl: Ctrl::Return(3, vec![14, 11]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(93, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(4, vec![12, 9]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(93, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(5, vec![12, 9]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 5), Op::Add(2, 5), Op::Call(93, vec![4, 6, 7], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(5)), Op::Store(vec![10, 11, 11, 11, 11, 8])], ctrl: Ctrl::Return(6, vec![12, 9]) }), (G::from_u64(6), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(86, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(93, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(6)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(7, vec![18, 15]) }), (G::from_u64(7), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(86, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(93, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(7)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(8, vec![18, 15]) }), (G::from_u64(8), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(86, vec![6], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("vk: expression child must precede its parent".into())), Op::Call(0, vec![7, 2], 1, false), Op::AssertEq(vec![11], vec![10], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 10), Op::Add(2, 10), Op::Call(93, vec![8, 12, 13], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Store(vec![16, 17, 5, 7, 16, 14])], ctrl: Ctrl::Return(9, vec![18, 15]) }), (G::from_u64(9), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Call(0, vec![5, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("vk: expression child must precede its parent".into())), Op::Sub(1, 8), Op::Add(2, 8), Op::Call(93, vec![6, 9, 10], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(9)), Op::Store(vec![13, 14, 5, 13, 13, 11])], ctrl: Ctrl::Return(10, vec![15, 12]) }), (G::from_u64(10), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 12, 5, 10])], ctrl: Ctrl::Return(11, vec![13, 11]) }), (G::from_u64(11), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 12, 7, 5, 10])], ctrl: Ctrl::Return(12, vec![13, 11]) }), (G::from_u64(12), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 12, 5, 10])], ctrl: Ctrl::Return(13, vec![13, 11]) }), (G::from_u64(13), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 7, 7, 7, 5, 10])], ctrl: Ctrl::Return(14, vec![13, 11]) }), (G::from_u64(14), Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 12, 5, 10])], ctrl: Ctrl::Return(15, vec![14, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(93, vec![6, 8, 9], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![12, 7, 13, 7, 5, 10])], ctrl: Ctrl::Return(16, vec![14, 11]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_94() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(94, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 2, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_95() -> Function { + Function { body: Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Call(86, vec![2], 2, false), Op::Call(94, vec![4, 3], 2, false)], ctrl: Ctrl::Return(0, vec![1, 5, 6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_96() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Call(86, vec![3], 2, false), Op::Call(94, vec![5, 4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(96, vec![7, 9], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 2, 6, 10])], ctrl: Ctrl::Return(1, vec![13, 11]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_97() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(2, 3), Op::Call(97, vec![4, 5, 2], 1, false), Op::Add(3, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(0, 3), Op::Sub(1, 3), Op::Call(97, vec![4, 5, 2], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_98() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![10], 10, false), Op::Call(88, vec![20], 10, false), Op::Call(87, vec![30], 10, false), Op::Call(85, vec![40], 2, false), Op::Call(86, vec![42], 2, false), Op::Const(G::from_u64(0)), Op::Call(93, vec![44, 43, 45], 2, false), Op::Call(86, vec![47], 2, false), Op::Call(94, vec![49, 48], 2, false), Op::Call(86, vec![51], 2, false), Op::Call(96, vec![53, 52], 2, false), Op::Call(97, vec![52, 45, 41], 1, false), Op::EqZero(56), Op::Add(56, 57), Op::Add(58, 58), Op::Add(48, 59), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(61, 62), Op::U8RangeCheck(63, 64), Op::U8RangeCheck(65, 66), Op::U8RangeCheck(67, 68), Op::Const(G::from_u64(256)), Op::Mul(69, 62), Op::Const(G::from_u64(65536)), Op::Mul(71, 63), Op::Const(G::from_u64(16777216)), Op::Mul(73, 64), Op::Const(G::from_u64(4294967296)), Op::Mul(75, 65), Op::Const(G::from_u64(1099511627776)), Op::Mul(77, 66), Op::Const(G::from_u64(281474976710656)), Op::Mul(79, 67), Op::Const(G::from_u64(72057594037927936)), Op::Mul(81, 68), Op::Add(80, 82), Op::Add(78, 83), Op::Add(76, 84), Op::Add(74, 85), Op::Add(72, 86), Op::Add(70, 87), Op::Add(61, 88), Op::AssertEq(vec![89], vec![60], None), Op::Const(G::from_u64(1020)), Op::Sub(68, 90), Op::Add(67, 91), Op::Add(66, 92), Op::Add(65, 93), Op::EqZero(94), Op::Add(63, 64), Op::Add(62, 96), Op::Add(61, 97), Op::EqZero(98), Op::Const(G::from_u64(1)), Op::Sub(100, 99), Op::Mul(95, 101), Op::Sub(100, 102), Op::AssertEq(vec![103], vec![100], None), Op::UnconstrainedGToBytes(59), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 107), Op::U8RangeCheck(108, 109), Op::U8RangeCheck(110, 111), Op::Mul(69, 105), Op::Mul(71, 106), Op::Mul(73, 107), Op::Mul(75, 108), Op::Mul(77, 109), Op::Mul(79, 110), Op::Mul(81, 111), Op::Add(117, 118), Op::Add(116, 119), Op::Add(115, 120), Op::Add(114, 121), Op::Add(113, 122), Op::Add(112, 123), Op::Add(104, 124), Op::AssertEq(vec![125], vec![59], None), Op::Sub(111, 90), Op::Add(110, 126), Op::Add(109, 127), Op::Add(108, 128), Op::EqZero(129), Op::Add(106, 107), Op::Add(105, 131), Op::Add(104, 132), Op::EqZero(133), Op::Sub(100, 134), Op::Mul(130, 135), Op::Sub(100, 136), Op::AssertEq(vec![137], vec![100], None), Op::UnconstrainedGToBytes(41), Op::U8RangeCheck(138, 139), Op::U8RangeCheck(140, 141), Op::U8RangeCheck(142, 143), Op::U8RangeCheck(144, 145), Op::Mul(69, 139), Op::Mul(71, 140), Op::Mul(73, 141), Op::Mul(75, 142), Op::Mul(77, 143), Op::Mul(79, 144), Op::Mul(81, 145), Op::Add(151, 152), Op::Add(150, 153), Op::Add(149, 154), Op::Add(148, 155), Op::Add(147, 156), Op::Add(146, 157), Op::Add(138, 158), Op::AssertEq(vec![159], vec![41], None), Op::Sub(145, 90), Op::Add(144, 160), Op::Add(143, 161), Op::Add(142, 162), Op::EqZero(163), Op::Add(140, 141), Op::Add(139, 165), Op::Add(138, 166), Op::EqZero(167), Op::Sub(100, 168), Op::Mul(164, 169), Op::Sub(100, 170), Op::AssertEq(vec![171], vec![100], None)], ctrl: Ctrl::Return(0, vec![46, 43, 50, 31, 54, 41, 1, 11, 59, 61, 62, 63, 64, 65, 66, 67, 68, 32, 33, 34, 35, 36, 37, 38, 39, 22, 23, 24, 25, 26, 27, 28, 29, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9, 104, 105, 106, 107, 108, 109, 110, 111, 138, 139, 140, 141, 142, 143, 144, 145, 55]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 97, lookups: 25 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_99() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![57, 48, 49, 50, 51, 52, 53, 54, 55, 56]), Op::Store(vec![57, 40, 41, 42, 43, 44, 45, 46, 47, 58]), Op::Store(vec![57, 32, 33, 34, 35, 36, 37, 38, 39, 59]), Op::Store(vec![57, 24, 25, 26, 27, 28, 29, 30, 31, 60]), Op::Store(vec![57, 16, 17, 18, 19, 20, 21, 22, 23, 61]), Op::Store(vec![57, 8, 9, 10, 11, 12, 13, 14, 15, 62]), Op::Store(vec![57, 0, 1, 2, 3, 4, 5, 6, 7, 63])], ctrl: Ctrl::Return(0, vec![64]) }, layout: FunctionLayout { input_size: 57, selectors: 1, auxiliaries: 8, lookups: 8 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_100() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![11], 10, false), Op::Call(88, vec![21], 10, false), Op::Call(87, vec![31], 10, false), Op::Call(85, vec![41], 2, false), Op::Call(86, vec![43], 2, false), Op::Const(G::from_u64(0)), Op::Call(93, vec![45, 44, 46], 2, false), Op::Call(86, vec![48], 2, false), Op::Call(94, vec![50, 49], 2, false), Op::Call(86, vec![52], 2, false), Op::Call(96, vec![54, 53], 2, false), Op::Call(97, vec![53, 46, 42], 1, false), Op::EqZero(57), Op::Add(57, 58), Op::Add(59, 59), Op::Add(49, 60), Op::UnconstrainedGToBytes(61), Op::U8RangeCheck(62, 63), Op::U8RangeCheck(64, 65), Op::U8RangeCheck(66, 67), Op::U8RangeCheck(68, 69), Op::Const(G::from_u64(256)), Op::Mul(70, 63), Op::Const(G::from_u64(65536)), Op::Mul(72, 64), Op::Const(G::from_u64(16777216)), Op::Mul(74, 65), Op::Const(G::from_u64(4294967296)), Op::Mul(76, 66), Op::Const(G::from_u64(1099511627776)), Op::Mul(78, 67), Op::Const(G::from_u64(281474976710656)), Op::Mul(80, 68), Op::Const(G::from_u64(72057594037927936)), Op::Mul(82, 69), Op::Add(81, 83), Op::Add(79, 84), Op::Add(77, 85), Op::Add(75, 86), Op::Add(73, 87), Op::Add(71, 88), Op::Add(62, 89), Op::AssertEq(vec![90], vec![61], None), Op::Const(G::from_u64(1020)), Op::Sub(69, 91), Op::Add(68, 92), Op::Add(67, 93), Op::Add(66, 94), Op::EqZero(95), Op::Add(64, 65), Op::Add(63, 97), Op::Add(62, 98), Op::EqZero(99), Op::Const(G::from_u64(1)), Op::Sub(101, 100), Op::Mul(96, 102), Op::Sub(101, 103), Op::AssertEq(vec![104], vec![101], None), Op::UnconstrainedGToBytes(60), Op::U8RangeCheck(105, 106), Op::U8RangeCheck(107, 108), Op::U8RangeCheck(109, 110), Op::U8RangeCheck(111, 112), Op::Mul(70, 106), Op::Mul(72, 107), Op::Mul(74, 108), Op::Mul(76, 109), Op::Mul(78, 110), Op::Mul(80, 111), Op::Mul(82, 112), Op::Add(118, 119), Op::Add(117, 120), Op::Add(116, 121), Op::Add(115, 122), Op::Add(114, 123), Op::Add(113, 124), Op::Add(105, 125), Op::AssertEq(vec![126], vec![60], None), Op::Sub(112, 91), Op::Add(111, 127), Op::Add(110, 128), Op::Add(109, 129), Op::EqZero(130), Op::Add(107, 108), Op::Add(106, 132), Op::Add(105, 133), Op::EqZero(134), Op::Sub(101, 135), Op::Mul(131, 136), Op::Sub(101, 137), Op::AssertEq(vec![138], vec![101], None), Op::UnconstrainedGToBytes(42), Op::U8RangeCheck(139, 140), Op::U8RangeCheck(141, 142), Op::U8RangeCheck(143, 144), Op::U8RangeCheck(145, 146), Op::Mul(70, 140), Op::Mul(72, 141), Op::Mul(74, 142), Op::Mul(76, 143), Op::Mul(78, 144), Op::Mul(80, 145), Op::Mul(82, 146), Op::Add(152, 153), Op::Add(151, 154), Op::Add(150, 155), Op::Add(149, 156), Op::Add(148, 157), Op::Add(147, 158), Op::Add(139, 159), Op::AssertEq(vec![160], vec![42], None), Op::Sub(146, 91), Op::Add(145, 161), Op::Add(144, 162), Op::Add(143, 163), Op::EqZero(164), Op::Add(141, 142), Op::Add(140, 166), Op::Add(139, 167), Op::EqZero(168), Op::Sub(101, 169), Op::Mul(165, 170), Op::Sub(101, 171), Op::AssertEq(vec![172], vec![101], None), Op::Sub(1, 101), Op::Call(100, vec![56, 173], 3, false), Op::Store(vec![46, 47, 44, 51, 32, 55, 42, 2, 12, 60, 174]), Op::Store(vec![46, 139, 140, 141, 142, 143, 144, 145, 146, 175]), Op::Store(vec![46, 105, 106, 107, 108, 109, 110, 111, 112, 178]), Op::Store(vec![46, 3, 4, 5, 6, 7, 8, 9, 10, 179]), Op::Store(vec![46, 13, 14, 15, 16, 17, 18, 19, 20, 180]), Op::Store(vec![46, 23, 24, 25, 26, 27, 28, 29, 30, 181]), Op::Store(vec![46, 33, 34, 35, 36, 37, 38, 39, 40, 182]), Op::Store(vec![46, 62, 63, 64, 65, 66, 67, 68, 69, 183])], ctrl: Ctrl::Return(1, vec![177, 184, 176]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_101() -> Function { + Function { body: Block { ops: vec![Op::Call(84, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![3, 3, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![2], 2, false), Op::Call(92, vec![4, 3], 2, false), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7, 5, 6]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_102() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(86, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(102, vec![3, 5], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(65535), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 9, 2, 6])], ctrl: Ctrl::Return(2, vec![10, 7]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_103() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![10], 10, false), Op::Call(87, vec![20], 10, false), Op::Call(87, vec![30], 10, false), Op::Call(87, vec![40], 10, false), Op::Call(87, vec![50], 10, false), Op::Call(87, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79])], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 80, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 79, lookups: 16 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_104() -> Function { + Function { body: Block { ops: vec![Op::Call(87, vec![0], 10, false), Op::Call(87, vec![10], 10, false), Op::Call(87, vec![20], 10, false), Op::Call(87, vec![30], 10, false), Op::Call(87, vec![40], 10, false), Op::Call(87, vec![50], 10, false), Op::Call(87, vec![60], 10, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![72, 72, 72, 72, 72, 72, 72, 72, 72, 72]), Op::Store(vec![71, 62, 63, 64, 65, 66, 67, 68, 69, 73]), Op::Store(vec![71, 52, 53, 54, 55, 56, 57, 58, 59, 74]), Op::Store(vec![71, 42, 43, 44, 45, 46, 47, 48, 49, 75]), Op::Store(vec![71, 32, 33, 34, 35, 36, 37, 38, 39, 76]), Op::Store(vec![71, 22, 23, 24, 25, 26, 27, 28, 29, 77]), Op::Store(vec![71, 12, 13, 14, 15, 16, 17, 18, 19, 78]), Op::Store(vec![71, 2, 3, 4, 5, 6, 7, 8, 9, 79]), Op::Call(87, vec![70], 10, false), Op::Call(100, vec![90, 81], 3, false), Op::Call(101, vec![93], 3, false), Op::Call(102, vec![96, 81], 2, false), Op::Store(vec![71, 82, 83, 84, 85, 86, 87, 88, 89, 92]), Op::Call(251, vec![80, 99], 1, false)], ctrl: Ctrl::Return(0, vec![1, 11, 21, 31, 41, 51, 61, 100, 91, 94, 95, 97, 98]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 99, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_105() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 4]), Op::Store(vec![5, 2, 6]), Op::Store(vec![5, 1, 7]), Op::Store(vec![5, 0, 8])], ctrl: Ctrl::Return(0, vec![9]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_106() -> Function { + Function { body: Block { ops: vec![Op::Call(105, vec![28, 29, 30, 31, 32], 1, false), Op::Call(105, vec![24, 25, 26, 27, 33], 1, false), Op::Call(105, vec![20, 21, 22, 23, 34], 1, false), Op::Call(105, vec![16, 17, 18, 19, 35], 1, false), Op::Call(105, vec![12, 13, 14, 15, 36], 1, false), Op::Call(105, vec![8, 9, 10, 11, 37], 1, false), Op::Call(105, vec![4, 5, 6, 7, 38], 1, false), Op::Call(105, vec![0, 1, 2, 3, 39], 1, false)], ctrl: Ctrl::Return(0, vec![40]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_107() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) }, layout: FunctionLayout { input_size: 32, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_108() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Load(32, 0), Op::Load(32, 1), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(11)), Op::Call(83, vec![97, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 3, 4, 5, 6, 7, 2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 97, 97, 97, 97, 97, 97, 97, 97, 98, 97, 97, 97, 99, 97, 97, 97, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96], 32, false), Op::Store(vec![100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131])], ctrl: Ctrl::Return(0, vec![132]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 98, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_109() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(108, vec![1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(108, vec![2, 1], 1, false)], ctrl: Ctrl::Return(1, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_110() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Sub(3, 1), Op::EqZero(5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(110, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_111() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Sub(7, 2), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(111, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(111, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(111, vec![5, 8, 2], 1, false), Op::Store(vec![21, 4, 22])], ctrl: Ctrl::Return(3, vec![23]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_112() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::U32LessThan(2, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(112, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(10, 4)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(112, vec![5, 8, 2], 1, false)], ctrl: Ctrl::Return(2, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(112, vec![5, 8, 2], 1, false), Op::Store(vec![20, 4, 21])], ctrl: Ctrl::Return(3, vec![22]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 27, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_113() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(12, 4), Op::Const(G::from_u64(65536)), Op::Mul(14, 5), Op::Const(G::from_u64(16777216)), Op::Mul(16, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 10), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(3, 31), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(33, 34), Op::U8RangeCheck(35, 36), Op::U8RangeCheck(37, 38), Op::U8RangeCheck(39, 40), Op::Mul(12, 34), Op::Mul(14, 35), Op::Mul(16, 36), Op::Mul(18, 37), Op::Mul(20, 38), Op::Mul(22, 39), Op::Mul(24, 40), Op::Add(46, 47), Op::Add(45, 48), Op::Add(44, 49), Op::Add(43, 50), Op::Add(42, 51), Op::Add(41, 52), Op::Add(33, 53), Op::AssertEq(vec![54], vec![32], None), Op::Const(G::from_u64(1020)), Op::Sub(40, 55), Op::Add(39, 56), Op::Add(38, 57), Op::Add(37, 58), Op::EqZero(59), Op::Add(35, 36), Op::Add(34, 61), Op::Add(33, 62), Op::EqZero(63), Op::Const(G::from_u64(1)), Op::Sub(65, 64), Op::Mul(60, 66), Op::Sub(65, 67), Op::AssertEq(vec![68], vec![65], None)], ctrl: Ctrl::Return(0, vec![33, 34, 35, 36, 37, 38, 39, 40, 11, 1, 65]) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![15, 15, 15, 15, 15, 15, 15, 15, 0, 1, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(113, vec![13, 14], 11, false)], ctrl: Ctrl::Return(2, vec![15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_114() -> Function { + Function { body: Block { ops: vec![Op::Call(113, vec![0, 1], 11, false)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Load(8, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 4), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Call(83, vec![57, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, 70, 71, 72, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 58, 59, 60, 61, 62, 63, 64, 65, 57, 57, 57, 57, 66, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57], 32, false), Op::Store(vec![57, 5, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113])], ctrl: Ctrl::Return(0, vec![114]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(5, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(6, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(7, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(8, vec![5]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(113, vec![14, 15], 11, false), Op::Call(113, vec![25, 26], 11, false), Op::Call(113, vec![36, 37], 11, false), Op::Call(113, vec![47, 48], 11, false), Op::Call(113, vec![58, 59], 11, false), Op::Call(113, vec![69, 70], 11, false), Op::Call(113, vec![80, 81], 11, false), Op::Const(G::from_u64(8)), Op::Add(82, 93), Op::Add(71, 95), Op::Add(60, 96), Op::Add(49, 97), Op::Add(38, 98), Op::Add(27, 99), Op::Add(16, 100), Op::Mul(94, 101), Op::Load(10, 91)], ctrl: Ctrl::MatchContinue(103, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(9, vec![116]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(10, vec![116]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(11, vec![113]) })), 1, 4, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(15)), Op::Sub(2, 114), Op::EqZero(115), Op::EqZero(2), Op::Mul(113, 116), Op::Sub(116, 118), Op::Add(113, 119), Op::Load(8, 3), Op::Call(2, vec![121, 122, 123, 124, 125, 126, 127, 128], 1, false), Op::Mul(113, 129), Op::Const(G::from_u64(2)), Op::Mul(131, 120), Op::Const(G::from_u64(8)), Op::Mul(133, 130), Op::Add(132, 134), Op::Add(117, 135), Op::Load(32, 4), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(0)), Op::Call(83, vec![184, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 169, 175, 176, 177, 178, 179, 180, 181, 182, 183, 121, 122, 123, 124, 125, 126, 127, 128, 102, 184, 184, 184, 136, 184, 184, 184, 6, 7, 8, 9, 10, 11, 12, 13, 17, 18, 19, 20, 21, 22, 23, 24, 28, 29, 30, 31, 32, 33, 34, 35, 39, 40, 41, 42, 43, 44, 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 61, 62, 63, 64, 65, 66, 67, 68, 72, 73, 74, 75, 76, 77, 78, 79, 83, 84, 85, 86, 87, 88, 89, 90], 32, false)], ctrl: Ctrl::Match(113, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![217, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216])], ctrl: Ctrl::Return(12, vec![218]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(116, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(0)), Op::Load(8, 3), Op::Call(11, vec![249, 250, 251, 252, 253, 254, 255, 256], 8, false), Op::Store(vec![257, 258, 259, 260, 261, 262, 263, 264]), Op::Store(vec![217, 218, 219, 220, 221, 222, 217, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247]), Op::Store(vec![248, 5, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(114, vec![91, 92, 248, 265, 266, 267], 1, false)], ctrl: Ctrl::Return(13, vec![268]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(2, 217), Op::Store(vec![185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216]), Op::Call(114, vec![91, 92, 218, 3, 219, 5], 1, false)], ctrl: Ctrl::Return(14, vec![220]) }))) }))) })) }))) }, layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_115() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Const(G::from_u64(0)), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34]), Op::Store(vec![1, 2, 3, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), Op::Store(vec![32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]), Op::Call(114, vec![33, 0, 34, 35, 36, 37], 1, false), Op::Call(74, vec![38], 32, false)], ctrl: Ctrl::Return(0, vec![39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 38, lookups: 7 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_116() -> Function { + Function { body: Block { ops: vec![Op::Call(111, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Const(G::from_u64(0)), Op::Store(vec![37, 37, 37, 37, 37, 37, 37, 37]), Op::Store(vec![4, 5, 6, 7, 8, 9, 4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35]), Op::Call(114, vec![36, 3, 37, 38, 39, 40], 1, false), Op::Call(74, vec![41], 32, false), Op::Store(vec![42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73])], ctrl: Ctrl::Return(0, vec![74]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 40, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_117() -> Function { + Function { body: Block { ops: vec![Op::Call(110, vec![1, 2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(116, vec![0, 1, 2], 1, false), Op::Call(108, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_118() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(118, vec![3], 1, false), Op::Mul(4, 5), Op::Add(2, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_119() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(0, vec![3, 9], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(119, vec![7, 1], 1, false), Op::Store(vec![15, 3, 4, 5, 6, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 9), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::AssertEq(vec![6], vec![12], None), Op::AssertEq(vec![5], vec![11], None), Op::Const(G::from_u64(0)), Op::Call(119, vec![7, 13], 1, false), Op::Store(vec![17, 3, 4, 5, 6, 18])], ctrl: Ctrl::Return(3, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(119, vec![0, 13], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 18])], ctrl: Ctrl::Return(4, vec![19]) }))) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_120() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14, 14, 14, 14]), Op::Store(vec![13, 2, 3, 4, 5, 15])], ctrl: Ctrl::Return(1, vec![16, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Call(120, vec![12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 13]), Op::Store(vec![15, 8, 9, 10, 11, 14])], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_121() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(6, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Call(120, vec![0], 2, false), Op::Call(121, vec![13], 1, false), Op::Call(121, vec![14], 1, false), Op::Call(119, vec![15, 16], 1, false)], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_122() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(241, vec![1], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![7], vec![8], None), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(116, vec![8, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(118, vec![5], 1, false), Op::Call(122, vec![6, 9, 2, 3], 1, false), Op::Store(vec![11, 12, 5, 8, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_123() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10, 10, 10, 10])], ctrl: Ctrl::Return(0, vec![11, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(118, vec![12], 1, false), Op::Load(6, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(118, vec![22], 1, false), Op::Sub(13, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Call(112, vec![7, 2, 3], 1, false), Op::Call(112, vec![17, 2, 3], 1, false), Op::AssertEq(vec![26], vec![27], None), Op::Call(108, vec![8, 18], 1, false), Op::Call(117, vec![7, 2, 3, 28], 1, false), Op::Call(123, vec![19, 1, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![32, 13, 12, 7, 29, 30])], ctrl: Ctrl::Return(1, vec![33, 31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Call(109, vec![11, 8, 27], 1, false), Op::Call(117, vec![7, 2, 3, 29], 1, false), Op::Call(123, vec![9, 28, 2, 3], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![33, 13, 12, 7, 30, 31])], ctrl: Ctrl::Return(2, vec![34, 32]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(109, vec![11, 8, 21], 1, false), Op::Call(117, vec![7, 2, 3, 23], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![26, 26, 26, 26, 26, 26]), Op::Store(vec![25, 13, 12, 7, 24, 27])], ctrl: Ctrl::Return(3, vec![28, 22]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 32, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_124() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 4), Op::Call(123, vec![0, 1, 2, 5], 2, false), Op::Call(124, vec![6, 7, 2, 5], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_125() -> Function { + Function { body: Block { ops: vec![Op::Call(241, vec![1], 1, false), Op::Call(241, vec![3], 1, false), Op::Sub(6, 7), Op::EqZero(8), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], None), Op::Call(122, vec![3, 1, 2, 5], 1, false), Op::Call(121, vec![11], 1, false), Op::Call(124, vec![12, 4, 2, 5], 2, false), Op::Call(241, vec![14], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], None), Op::Load(6, 13)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(244, vec![22], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![0, 18], 1, false), Op::Sub(25, 21), Op::EqZero(26)], ctrl: Ctrl::Return(0, vec![27]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 20, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_126() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(126, vec![4, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_127() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(0, 0), Op::Call(127, vec![5, 4], 1, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 6)], ctrl: Ctrl::Return(2, vec![7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_128() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 8), Op::Call(183, vec![9], 1, false), Op::Store(vec![8, 8, 8]), Op::Call(126, vec![0, 11], 1, false), Op::Call(127, vec![10, 12], 1, false), Op::Add(13, 13), Op::Add(4, 6), Op::Add(5, 7), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Mul(17, 17), Op::Const(G::from_u64(7)), Op::Mul(18, 18), Op::Mul(20, 21), Op::Sub(19, 22), Op::UnconstrainedGInverse(23), Op::Mul(23, 24), Op::Sub(25, 8), Op::Mul(23, 26), Op::AssertEq(vec![27], vec![18], None), Op::Mul(24, 26), Op::AssertEq(vec![28], vec![18], None), Op::Mul(17, 24), Op::Sub(18, 18), Op::Mul(30, 24), Op::Mul(15, 29), Op::Mul(16, 31), Op::Mul(20, 33), Op::Add(32, 34), Op::Mul(15, 31), Op::Mul(16, 29), Op::Add(36, 37), Op::Sub(4, 6), Op::Sub(5, 7), Op::Mul(14, 14), Op::Sub(41, 22), Op::UnconstrainedGInverse(42), Op::Mul(42, 43), Op::Sub(44, 8), Op::Mul(42, 45), Op::AssertEq(vec![46], vec![18], None), Op::Mul(43, 45), Op::AssertEq(vec![47], vec![18], None), Op::Mul(14, 43), Op::Mul(30, 43), Op::Mul(39, 48), Op::Mul(40, 49), Op::Mul(20, 51), Op::Add(50, 52), Op::Mul(39, 49), Op::Mul(40, 48), Op::Add(54, 55), Op::Mul(2, 53), Op::Mul(3, 56), Op::Mul(20, 58), Op::Add(57, 59), Op::Mul(2, 56), Op::Mul(3, 53), Op::Add(61, 62), Op::Add(35, 60), Op::Add(38, 63)], ctrl: Ctrl::Return(0, vec![64, 65]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 25, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_129() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(183, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(126, vec![0, 5], 1, false), Op::Call(127, vec![3, 6], 1, false), Op::Mul(2, 7)], ctrl: Ctrl::Return(0, vec![8]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_130() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(22, 10), Op::Const(G::from_u64(65536)), Op::Mul(24, 11), Op::Const(G::from_u64(16777216)), Op::Mul(26, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(28, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(30, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(32, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(34, 16), Op::Add(33, 35), Op::Add(31, 36), Op::Add(29, 37), Op::Add(27, 38), Op::Add(25, 39), Op::Add(23, 40), Op::Add(9, 41), Op::Const(G::from_u64(0)), Op::Sub(19, 42), Op::Sub(20, 43), Op::Mul(6, 44), Op::Const(G::from_u64(7)), Op::Mul(7, 45), Op::Mul(47, 48), Op::Add(46, 49), Op::Mul(6, 45), Op::Mul(7, 44), Op::Add(51, 52), Op::Add(4, 50), Op::Add(5, 53), Op::Mul(6, 2), Op::Mul(7, 3), Op::Mul(47, 57), Op::Add(56, 58), Op::Mul(6, 3), Op::Mul(7, 2), Op::Add(60, 61), Op::Call(130, vec![17, 21, 2, 3, 54, 55, 59, 62], 4, false)], ctrl: Ctrl::Return(1, vec![63, 64, 65, 66]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_131() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::U8RangeCheck(12, 13), Op::Const(G::from_u64(256)), Op::Mul(14, 7), Op::Const(G::from_u64(65536)), Op::Mul(16, 8), Op::Const(G::from_u64(16777216)), Op::Mul(18, 9), Op::Const(G::from_u64(4294967296)), Op::Mul(20, 10), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 11), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 12), Op::Const(G::from_u64(72057594037927936)), Op::Mul(26, 13), Op::Add(25, 27), Op::Add(23, 28), Op::Add(21, 29), Op::Add(19, 30), Op::Add(17, 31), Op::Add(15, 32), Op::Add(6, 33), Op::AssertEq(vec![34], vec![3], None), Op::Const(G::from_u64(1020)), Op::Sub(13, 35), Op::Add(12, 36), Op::Add(11, 37), Op::Add(10, 38), Op::EqZero(39), Op::Add(8, 9), Op::Add(7, 41), Op::Add(6, 42), Op::EqZero(43), Op::Const(G::from_u64(1)), Op::Sub(45, 44), Op::Mul(40, 46), Op::Sub(45, 47), Op::AssertEq(vec![48], vec![45], None), Op::UnconstrainedGToBytes(4), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::U8RangeCheck(55, 56), Op::Mul(14, 50), Op::Mul(16, 51), Op::Mul(18, 52), Op::Mul(20, 53), Op::Mul(22, 54), Op::Mul(24, 55), Op::Mul(26, 56), Op::Add(62, 63), Op::Add(61, 64), Op::Add(60, 65), Op::Add(59, 66), Op::Add(58, 67), Op::Add(57, 68), Op::Add(49, 69), Op::AssertEq(vec![70], vec![4], None), Op::Sub(56, 35), Op::Add(55, 71), Op::Add(54, 72), Op::Add(53, 73), Op::EqZero(74), Op::Add(51, 52), Op::Add(50, 76), Op::Add(49, 77), Op::EqZero(78), Op::Sub(45, 79), Op::Mul(75, 80), Op::Sub(45, 81), Op::AssertEq(vec![82], vec![45], None), Op::Call(131, vec![5, 1], 1, false), Op::Call(168, vec![49, 50, 51, 52, 53, 54, 55, 56, 83], 1, false), Op::Call(168, vec![6, 7, 8, 9, 10, 11, 12, 13, 84], 1, false)], ctrl: Ctrl::Return(1, vec![85]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 34, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_132() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(132, vec![4, 1], 1, false), Op::Call(131, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_133() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(133, vec![4, 1], 1, false), Op::Call(132, vec![3, 5], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_134() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Call(133, vec![1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![3]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_135() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(177, vec![0, 5, 6, 6, 6, 6, 6, 6, 6], 1, false), Op::Call(135, vec![7, 4], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_136() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10])], ctrl: Ctrl::Return(0, vec![0, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(177, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Call(176, vec![10, 12, 9], 3, false), Op::Call(118, vec![13], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![14, 15]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_137() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8, 0]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(178, vec![0, 5], 1, false), Op::Call(136, vec![17, 8, 9, 10, 11, 12, 13, 14, 15, 3], 2, false), Op::Call(174, vec![18, 19], 18, false), Op::Call(137, vec![36, 6, 16, 3], 2, false), Op::Const(G::from_u64(256)), Op::Mul(40, 21), Op::Const(G::from_u64(65536)), Op::Mul(42, 22), Op::Const(G::from_u64(16777216)), Op::Mul(44, 23), Op::Const(G::from_u64(4294967296)), Op::Mul(46, 24), Op::Const(G::from_u64(1099511627776)), Op::Mul(48, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(50, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(52, 27), Op::Add(51, 53), Op::Add(49, 54), Op::Add(47, 55), Op::Add(45, 56), Op::Add(43, 57), Op::Add(41, 58), Op::Add(20, 59), Op::Const(G::from_u64(0)), Op::Mul(40, 29), Op::Mul(42, 30), Op::Mul(44, 31), Op::Mul(46, 32), Op::Mul(48, 33), Op::Mul(50, 34), Op::Mul(52, 35), Op::Add(67, 68), Op::Add(66, 69), Op::Add(65, 70), Op::Add(64, 71), Op::Add(63, 72), Op::Add(62, 73), Op::Add(28, 74), Op::Store(vec![61, 60, 75, 38])], ctrl: Ctrl::Return(1, vec![76, 39]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 38, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_138() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![0, 3], 1, false), Op::Sub(1, 4), Op::Add(5, 6), Op::EqZero(7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 9), Op::Add(3, 9), Op::Call(138, vec![0, 1, 10, 11, 4], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_139() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(138, vec![0, 1, 2, 4, 3], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 6), Op::Call(139, vec![0, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Call(139, vec![0, 1, 2, 8], 1, false), Op::Store(vec![6, 3, 7, 6, 6, 6, 9])], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_140() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(9, 1), Op::EqZero(15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(130, vec![2, 3, 6, 7, 17, 17, 10, 11], 4, false), Op::Mul(4, 18), Op::Const(G::from_u64(7)), Op::Mul(5, 19), Op::Mul(23, 24), Op::Add(22, 25), Op::Mul(4, 19), Op::Mul(5, 18), Op::Add(27, 28), Op::Add(12, 26), Op::Add(13, 29), Op::Store(vec![17, 9, 20, 21, 30, 31, 14])], ctrl: Ctrl::Return(1, vec![32]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(140, vec![14, 1, 2, 3, 4, 5, 6, 7], 1, false), Op::Store(vec![17, 9, 10, 11, 12, 13, 18])], ctrl: Ctrl::Return(2, vec![19]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_141() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(3, 1), Op::EqZero(9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(6, 11), Op::EqZero(12), Op::Sub(7, 11), Op::EqZero(14), Op::Mul(13, 15), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None)], ctrl: Ctrl::Return(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(141, vec![8, 1], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_142() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![2]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_143() -> Function { + Function { body: Block { ops: vec![Op::Call(246, vec![6], 1, false), Op::Call(242, vec![7], 1, false), Op::Sub(10, 11), Op::EqZero(12), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], None), Op::Sub(3, 1), Op::Call(253, vec![2, 15], 1, false), Op::Const(G::from_u64(7)), Op::Call(183, vec![1], 1, false), Op::Store(vec![14, 14, 14]), Op::Call(126, vec![16, 19], 1, false), Op::Call(127, vec![18, 20], 1, false), Op::Mul(17, 21), Op::Const(G::from_u64(0)), Op::Sub(4, 22), Op::Sub(5, 23), Op::Mul(24, 24), Op::Mul(25, 25), Op::Mul(17, 27), Op::Sub(26, 28), Op::UnconstrainedGInverse(29), Op::Mul(29, 30), Op::Sub(31, 14), Op::Mul(29, 32), Op::AssertEq(vec![33], vec![23], None), Op::Mul(30, 32), Op::AssertEq(vec![34], vec![23], None), Op::Mul(24, 30), Op::Sub(23, 25), Op::Mul(36, 30), Op::Call(140, vec![0, 1, 6, 7, 35, 37, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![38]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_144() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![8, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(239, vec![8, 13], 1, false), Op::Call(183, vec![4], 1, false), Op::Mul(5, 15), Op::Const(G::from_u64(7)), Op::Mul(6, 11), Op::Mul(17, 18), Op::Add(16, 19), Op::Mul(5, 11), Op::Mul(6, 15), Op::Add(21, 22), Op::Call(143, vec![0, 3, 1, 2, 5, 6, 7, 12, 9, 10], 1, false), Op::Call(143, vec![24, 3, 1, 2, 20, 23, 7, 14, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![25]) }, layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_145() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(239, vec![9, 4], 1, false), Op::Call(239, vec![10, 4], 1, false), Op::Call(144, vec![0, 1, 2, 14, 13, 7, 8, 15, 16, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 18), Op::Sub(5, 18), Op::Call(145, vec![17, 1, 2, 3, 19, 20, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![21]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_146() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(239, vec![9, 4], 1, false), Op::Call(239, vec![10, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![16, 17], 1, false), Op::Call(143, vec![0, 14, 1, 2, 7, 8, 15, 18, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 20), Op::Sub(5, 20), Op::Call(146, vec![19, 1, 2, 3, 21, 22, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Return(1, vec![23]) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 8, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_147() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![8, 4], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 17), Op::Sub(5, 17), Op::Call(147, vec![0, 1, 2, 3, 18, 19, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![20]) }), (G::from_u64(1), Block { ops: vec![Op::Call(239, vec![7, 4], 1, false), Op::Add(17, 3), Op::Call(239, vec![11, 6], 1, false), Op::Call(239, vec![12, 6], 1, false), Op::Call(144, vec![0, 1, 2, 18, 17, 9, 10, 19, 20, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 22), Op::Sub(5, 22), Op::Add(6, 22), Op::Call(147, vec![21, 1, 2, 3, 23, 24, 25, 7, 8, 9, 10, 11, 12, 13, 14], 1, false)], ctrl: Ctrl::Return(2, vec![26]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_148() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(239, vec![1, 15], 1, false)], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![16], 1, false), Op::Call(241, vec![4], 1, false), Op::Sub(17, 18), Op::EqZero(19), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Const(G::from_u64(0)), Op::Call(151, vec![6, 10, 5, 7, 22], 1, false), Op::Call(150, vec![23], 1, false), Op::Call(147, vec![0, 8, 9, 10, 22, 7, 22, 6, 5, 11, 12, 16, 4, 13, 14], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_149() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![0, 3], 1, false), Op::Add(5, 1), Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Add(3, 7), Op::Call(149, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_150() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(150, vec![3], 1, false), Op::U32LessThan(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![2]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 12, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_151() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 7), Op::Add(4, 7), Op::Call(151, vec![0, 1, 2, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![0, 4], 1, false), Op::Add(8, 1), Op::Const(G::from_u64(1)), Op::Sub(3, 10), Op::Add(4, 10), Op::Call(151, vec![0, 1, 2, 11, 12], 1, false), Op::Store(vec![7, 9, 13])], ctrl: Ctrl::Return(2, vec![14]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_152() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1, 2, 3, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_153() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::U8RangeCheck(10, 11), Op::Const(G::from_u64(256)), Op::Mul(12, 5), Op::Const(G::from_u64(65536)), Op::Mul(14, 6), Op::Const(G::from_u64(16777216)), Op::Mul(16, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(22, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(24, 11), Op::Add(23, 25), Op::Add(21, 26), Op::Add(19, 27), Op::Add(17, 28), Op::Add(15, 29), Op::Add(13, 30), Op::Add(4, 31), Op::AssertEq(vec![32], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(11, 33), Op::Add(10, 34), Op::Add(9, 35), Op::Add(8, 36), Op::EqZero(37), Op::Add(6, 7), Op::Add(5, 39), Op::Add(4, 40), Op::EqZero(41), Op::Const(G::from_u64(1)), Op::Sub(43, 42), Op::Mul(38, 44), Op::Sub(43, 45), Op::AssertEq(vec![46], vec![43], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(47, 48), Op::U8RangeCheck(49, 50), Op::U8RangeCheck(51, 52), Op::U8RangeCheck(53, 54), Op::Mul(12, 48), Op::Mul(14, 49), Op::Mul(16, 50), Op::Mul(18, 51), Op::Mul(20, 52), Op::Mul(22, 53), Op::Mul(24, 54), Op::Add(60, 61), Op::Add(59, 62), Op::Add(58, 63), Op::Add(57, 64), Op::Add(56, 65), Op::Add(55, 66), Op::Add(47, 67), Op::AssertEq(vec![68], vec![1], None), Op::Sub(54, 33), Op::Add(53, 69), Op::Add(52, 70), Op::Add(51, 71), Op::EqZero(72), Op::Add(49, 50), Op::Add(48, 74), Op::Add(47, 75), Op::EqZero(76), Op::Sub(43, 77), Op::Mul(73, 78), Op::Sub(43, 79), Op::AssertEq(vec![80], vec![43], None), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(81, 82), Op::U8RangeCheck(83, 84), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::Mul(12, 82), Op::Mul(14, 83), Op::Mul(16, 84), Op::Mul(18, 85), Op::Mul(20, 86), Op::Mul(22, 87), Op::Mul(24, 88), Op::Add(94, 95), Op::Add(93, 96), Op::Add(92, 97), Op::Add(91, 98), Op::Add(90, 99), Op::Add(89, 100), Op::Add(81, 101), Op::AssertEq(vec![102], vec![2], None), Op::Sub(88, 33), Op::Add(87, 103), Op::Add(86, 104), Op::Add(85, 105), Op::EqZero(106), Op::Add(83, 84), Op::Add(82, 108), Op::Add(81, 109), Op::EqZero(110), Op::Sub(43, 111), Op::Mul(107, 112), Op::Sub(43, 113), Op::AssertEq(vec![114], vec![43], None), Op::UnconstrainedGToBytes(3), Op::U8RangeCheck(115, 116), Op::U8RangeCheck(117, 118), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::Mul(12, 116), Op::Mul(14, 117), Op::Mul(16, 118), Op::Mul(18, 119), Op::Mul(20, 120), Op::Mul(22, 121), Op::Mul(24, 122), Op::Add(128, 129), Op::Add(127, 130), Op::Add(126, 131), Op::Add(125, 132), Op::Add(124, 133), Op::Add(123, 134), Op::Add(115, 135), Op::AssertEq(vec![136], vec![3], None), Op::Sub(122, 33), Op::Add(121, 137), Op::Add(120, 138), Op::Add(119, 139), Op::EqZero(140), Op::Add(117, 118), Op::Add(116, 142), Op::Add(115, 143), Op::EqZero(144), Op::Sub(43, 145), Op::Mul(141, 146), Op::Sub(43, 147), Op::AssertEq(vec![148], vec![43], None), Op::Const(G::from_u64(0)), Op::Store(vec![43, 43, 43, 43, 43, 43, 43, 43, 43, 43]), Op::Store(vec![149, 115, 116, 117, 118, 119, 120, 121, 122, 150]), Op::Store(vec![149, 81, 82, 83, 84, 85, 86, 87, 88, 151]), Op::Store(vec![149, 47, 48, 49, 50, 51, 52, 53, 54, 152]), Op::Store(vec![149, 4, 5, 6, 7, 8, 9, 10, 11, 153])], ctrl: Ctrl::Return(0, vec![154]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 58, lookups: 22 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_154() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1, 5]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(7, 2), Op::EqZero(13)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(182, vec![3, 4, 15], 2, false), Op::Mul(16, 10), Op::Const(G::from_u64(7)), Op::Mul(17, 11), Op::Mul(19, 20), Op::Add(18, 21), Op::Mul(16, 11), Op::Mul(17, 10), Op::Add(23, 24), Op::Add(0, 22), Op::Add(1, 25)], ctrl: Ctrl::Return(1, vec![26, 27, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![0, 1, 5]) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 16, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_155() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Sub(6, 8), Op::EqZero(13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], None), Op::Call(245, vec![7], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![16], vec![17], None), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![0, 1, 18]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(10, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(242, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], None), Op::Load(3, 5)], ctrl: Ctrl::Match(22, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(6, 25), Op::Const(G::from_u64(0)), Op::Call(250, vec![11, 27], 2, false)], ctrl: Ctrl::MatchContinue(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![0, 1, 28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![28, 29, 0, 1]) })), 4, 1, 0, Box::new(Block { ops: vec![Op::Call(128, vec![24, 26, 14, 15, 30, 31, 32, 33], 2, false), Op::Call(154, vec![34, 35, 26, 14, 15, 7], 3, false), Op::Call(155, vec![36, 37, 16, 19, 12, 24, 26, 38, 8], 3, false), Op::UnconstrainedGToBytes(30), Op::U8RangeCheck(42, 43), Op::U8RangeCheck(44, 45), Op::U8RangeCheck(46, 47), Op::U8RangeCheck(48, 49), Op::Const(G::from_u64(256)), Op::Mul(50, 43), Op::Const(G::from_u64(65536)), Op::Mul(52, 44), Op::Const(G::from_u64(16777216)), Op::Mul(54, 45), Op::Const(G::from_u64(4294967296)), Op::Mul(56, 46), Op::Const(G::from_u64(1099511627776)), Op::Mul(58, 47), Op::Const(G::from_u64(281474976710656)), Op::Mul(60, 48), Op::Const(G::from_u64(72057594037927936)), Op::Mul(62, 49), Op::Add(61, 63), Op::Add(59, 64), Op::Add(57, 65), Op::Add(55, 66), Op::Add(53, 67), Op::Add(51, 68), Op::Add(42, 69), Op::AssertEq(vec![70], vec![30], None), Op::Const(G::from_u64(1020)), Op::Sub(49, 71), Op::Add(48, 72), Op::Add(47, 73), Op::Add(46, 74), Op::EqZero(75), Op::Add(44, 45), Op::Add(43, 77), Op::Add(42, 78), Op::EqZero(79), Op::Const(G::from_u64(1)), Op::Sub(81, 80), Op::Mul(76, 82), Op::Sub(81, 83), Op::AssertEq(vec![84], vec![81], None), Op::UnconstrainedGToBytes(31), Op::U8RangeCheck(85, 86), Op::U8RangeCheck(87, 88), Op::U8RangeCheck(89, 90), Op::U8RangeCheck(91, 92), Op::Mul(50, 86), Op::Mul(52, 87), Op::Mul(54, 88), Op::Mul(56, 89), Op::Mul(58, 90), Op::Mul(60, 91), Op::Mul(62, 92), Op::Add(98, 99), Op::Add(97, 100), Op::Add(96, 101), Op::Add(95, 102), Op::Add(94, 103), Op::Add(93, 104), Op::Add(85, 105), Op::AssertEq(vec![106], vec![31], None), Op::Sub(92, 71), Op::Add(91, 107), Op::Add(90, 108), Op::Add(89, 109), Op::EqZero(110), Op::Add(87, 88), Op::Add(86, 112), Op::Add(85, 113), Op::EqZero(114), Op::Sub(81, 115), Op::Mul(111, 116), Op::Sub(81, 117), Op::AssertEq(vec![118], vec![81], None), Op::UnconstrainedGToBytes(32), Op::U8RangeCheck(119, 120), Op::U8RangeCheck(121, 122), Op::U8RangeCheck(123, 124), Op::U8RangeCheck(125, 126), Op::Mul(50, 120), Op::Mul(52, 121), Op::Mul(54, 122), Op::Mul(56, 123), Op::Mul(58, 124), Op::Mul(60, 125), Op::Mul(62, 126), Op::Add(132, 133), Op::Add(131, 134), Op::Add(130, 135), Op::Add(129, 136), Op::Add(128, 137), Op::Add(127, 138), Op::Add(119, 139), Op::AssertEq(vec![140], vec![32], None), Op::Sub(126, 71), Op::Add(125, 141), Op::Add(124, 142), Op::Add(123, 143), Op::EqZero(144), Op::Add(121, 122), Op::Add(120, 146), Op::Add(119, 147), Op::EqZero(148), Op::Sub(81, 149), Op::Mul(145, 150), Op::Sub(81, 151), Op::AssertEq(vec![152], vec![81], None), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(153, 154), Op::U8RangeCheck(155, 156), Op::U8RangeCheck(157, 158), Op::U8RangeCheck(159, 160), Op::Mul(50, 154), Op::Mul(52, 155), Op::Mul(54, 156), Op::Mul(56, 157), Op::Mul(58, 158), Op::Mul(60, 159), Op::Mul(62, 160), Op::Add(166, 167), Op::Add(165, 168), Op::Add(164, 169), Op::Add(163, 170), Op::Add(162, 171), Op::Add(161, 172), Op::Add(153, 173), Op::AssertEq(vec![174], vec![33], None), Op::Sub(160, 71), Op::Add(159, 175), Op::Add(158, 176), Op::Add(157, 177), Op::EqZero(178), Op::Add(155, 156), Op::Add(154, 180), Op::Add(153, 181), Op::EqZero(182), Op::Sub(81, 183), Op::Mul(179, 184), Op::Sub(81, 185), Op::AssertEq(vec![186], vec![81], None), Op::Const(G::from_u64(0)), Op::Store(vec![81, 81, 81, 81, 81, 81, 81, 81, 81, 81]), Op::Store(vec![187, 153, 154, 155, 156, 157, 158, 159, 160, 188]), Op::Store(vec![187, 119, 120, 121, 122, 123, 124, 125, 126, 189]), Op::Store(vec![187, 85, 86, 87, 88, 89, 90, 91, 92, 190]), Op::Store(vec![187, 42, 43, 44, 45, 46, 47, 48, 49, 191]), Op::Store(vec![187, 192, 41])], ctrl: Ctrl::Return(3, vec![39, 40, 193]) })) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 4, auxiliaries: 89, lookups: 32 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_156() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(242, vec![2], 1, false), Op::Sub(25, 24), Op::EqZero(26), Op::Const(G::from_u64(1)), Op::AssertEq(vec![27], vec![28], None), Op::Call(241, vec![1], 1, false), Op::Const(G::from_u64(3)), Op::Call(142, vec![8, 9], 1, false), Op::Add(30, 31), Op::Sub(29, 32), Op::EqZero(33), Op::AssertEq(vec![34], vec![28], None), Op::Call(139, vec![15, 19, 18, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(149, vec![15, 19, 18, 36], 1, false), Op::Call(239, vec![1, 36], 1, false)], ctrl: Ctrl::Match(38, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![38], 1, false), Op::Sub(39, 18), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::AssertEq(vec![41], vec![42], None), Op::Const(G::from_u64(0)), Op::Call(145, vec![35, 0, 20, 19, 43, 18, 15, 16, 17, 38, 5, 3, 4], 1, false), Op::Call(239, vec![1, 42], 1, false)], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![45], 1, false), Op::Sub(46, 18), Op::EqZero(47), Op::Const(G::from_u64(1)), Op::AssertEq(vec![48], vec![49], None), Op::Const(G::from_u64(0)), Op::Call(145, vec![44, 0, 20, 19, 50, 18, 15, 16, 17, 45, 6, 3, 4], 1, false), Op::Const(G::from_u64(2)), Op::Call(239, vec![1, 52], 1, false)], ctrl: Ctrl::Match(53, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![53], 1, false), Op::Sub(54, 18), Op::EqZero(55), Op::Const(G::from_u64(1)), Op::AssertEq(vec![56], vec![57], None), Op::Const(G::from_u64(0)), Op::Call(146, vec![51, 0, 20, 19, 58, 18, 15, 16, 17, 53, 7, 3, 4], 1, false), Op::Call(148, vec![59, 1, 13, 8, 9, 14, 15, 18, 0, 20, 19, 16, 17, 3, 4], 1, false), Op::Call(141, vec![60, 19], 1, false), Op::Load(7, 60)], ctrl: Ctrl::Match(62, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(63, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(63, 20), Op::EqZero(69), Op::Const(G::from_u64(1)), Op::AssertEq(vec![70], vec![71], None), Op::Call(155, vec![66, 67, 21, 22, 2, 0, 20, 68, 19], 3, false), Op::Const(G::from_u64(0)), Op::Call(250, vec![23, 75], 2, false), Op::Sub(76, 72), Op::EqZero(78), Op::Sub(77, 73), Op::EqZero(80), Op::Mul(79, 81), Op::AssertEq(vec![82], vec![71], None)], ctrl: Ctrl::Return(0, vec![74]) }))) })].into_iter().collect(), None) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 25, selectors: 1, auxiliaries: 46, lookups: 20 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_157() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![29, 29, 29])], ctrl: Ctrl::Return(0, vec![30]) }), (G::from_u64(0), Block { ops: vec![Op::Call(176, vec![0, 1, 20], 3, false), Op::Call(156, vec![29, 26, 27, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Const(G::from_u64(0)), Op::Call(157, vec![30, 31, 28, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Store(vec![33, 32, 34])], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 25, selectors: 2, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_158() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(176, vec![0, 1, 3], 3, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(158, vec![5, 6, 9, 3], 1, false), Op::Store(vec![7, 4, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_159() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![3, 1], 1, false), Op::Call(159, vec![5, 1], 1, false), Op::Store(vec![6, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_160() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![4, 1], 1, false), Op::Call(160, vec![6, 1], 1, false), Op::Store(vec![7, 3, 8, 9])], ctrl: Ctrl::Return(1, vec![10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_161() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(159, vec![0, 2], 1, false), Op::Call(160, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Sub(3, 7), Op::Call(161, vec![0, 1, 8, 9], 1, false), Op::Store(vec![4, 5, 6, 10])], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_162() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(149, vec![9, 11, 10, 13], 1, false), Op::Call(250, vec![0, 13], 2, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(250, vec![0, 17], 2, false)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(250, vec![0, 20], 2, false)], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(125, vec![2, 15, 14, 1, 16, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![23], vec![24], None), Op::Call(125, vec![3, 18, 14, 1, 19, 12], 1, false), Op::AssertEq(vec![25], vec![24], None), Op::Call(125, vec![4, 21, 14, 1, 22, 12], 1, false), Op::AssertEq(vec![26], vec![24], None)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(250, vec![0, 27], 2, false)], ctrl: Ctrl::Match(28, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(151, vec![9, 11, 8, 10, 30], 1, false), Op::Call(150, vec![31], 1, false), Op::Sub(12, 32), Op::Call(163, vec![1, 33], 1, false), Op::Call(125, vec![5, 28, 31, 34, 29, 32], 1, false)], ctrl: Ctrl::Return(1, vec![35]) }))) })].into_iter().collect(), None) }))) }))) }))) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 17, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_163() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(253, vec![3, 1], 1, false), Op::Call(163, vec![4, 1], 1, false), Op::Store(vec![5, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_164() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(239, vec![3, 1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![5, 6, 8]), Op::Call(164, vec![4, 1], 1, false), Op::Store(vec![5, 9, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_165() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(241, vec![1], 1, false), Op::EqZero(11)], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![14], None), Op::Call(241, vec![8], 1, false), Op::Call(241, vec![3], 1, false), Op::AssertEq(vec![15], vec![16], None), Op::Call(163, vec![3, 14], 1, false), Op::Sub(5, 14), Op::Call(164, vec![2, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 14, 14]), Op::Store(vec![20, 18, 21]), Op::Call(125, vec![12, 19, 22, 17, 9, 18], 1, false), Op::AssertEq(vec![23], vec![14], None), Op::Add(4, 14), Op::Call(165, vec![10, 13, 2, 17, 24, 18], 1, false)], ctrl: Ctrl::Return(1, vec![25]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_166() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![6], 1, false), Op::Call(246, vec![7], 1, false), Op::Sub(33, 32), Op::EqZero(34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(242, vec![8], 1, false), Op::Const(G::from_u64(3)), Op::Call(142, vec![4, 5], 1, false), Op::Add(38, 39), Op::AssertEq(vec![37], vec![40], None), Op::Call(252, vec![9], 1, false), Op::Sub(41, 32), Op::EqZero(42), Op::AssertEq(vec![43], vec![36], None), Op::Call(242, vec![10], 1, false), Op::AssertEq(vec![44], vec![36], None), Op::Store(vec![36, 36, 36])], ctrl: Ctrl::MatchContinue(4, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![45]) }), (G::from_u64(1), Block { ops: vec![Op::Call(133, vec![5, 45], 1, false)], ctrl: Ctrl::Yield(1, vec![46]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(133, vec![3, 46], 1, false), Op::Call(133, vec![2, 47], 1, false), Op::Call(133, vec![1, 48], 1, false), Op::Call(243, vec![0, 49], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Call(174, vec![50, 52], 18, false), Op::Const(G::from_u64(256)), Op::Mul(71, 54), Op::Const(G::from_u64(65536)), Op::Mul(73, 55), Op::Const(G::from_u64(16777216)), Op::Mul(75, 56), Op::Const(G::from_u64(4294967296)), Op::Mul(77, 57), Op::Const(G::from_u64(1099511627776)), Op::Mul(79, 58), Op::Const(G::from_u64(281474976710656)), Op::Mul(81, 59), Op::Const(G::from_u64(72057594037927936)), Op::Mul(83, 60), Op::Add(82, 84), Op::Add(80, 85), Op::Add(78, 86), Op::Add(76, 87), Op::Add(74, 88), Op::Add(72, 89), Op::Add(53, 90), Op::Mul(71, 62), Op::Mul(73, 63), Op::Mul(75, 64), Op::Mul(77, 65), Op::Mul(79, 66), Op::Mul(81, 67), Op::Mul(83, 68), Op::Add(97, 98), Op::Add(96, 99), Op::Add(95, 100), Op::Add(94, 101), Op::Add(93, 102), Op::Add(92, 103), Op::Add(61, 104), Op::Call(137, vec![69, 6, 7, 30], 2, false), Op::Call(131, vec![10, 52], 1, false), Op::Call(243, vec![107, 108], 1, false), Op::Call(135, vec![109, 6], 1, false), Op::Call(136, vec![110, 11, 12, 13, 14, 15, 16, 17, 18, 31], 2, false), Op::Add(32, 28), Op::Const(G::from_u64(33)), Op::U32LessThan(113, 114), Op::AssertEq(vec![115], vec![51], None), Op::Call(158, vec![111, 112, 29, 113], 1, false), Op::Call(162, vec![8, 116, 19, 20, 21, 22, 4, 5, 23, 24, 27, 28, 113], 1, false), Op::AssertEq(vec![117], vec![51], None), Op::Const(G::from_u64(0)), Op::Call(161, vec![8, 9, 118, 29], 1, false), Op::Call(157, vec![111, 112, 119, 91, 105, 1, 2, 3, 4, 5, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 113, 106, 6, 10, 32], 1, false), Op::Call(165, vec![9, 6, 120, 116, 118, 113], 1, false)], ctrl: Ctrl::Return(2, vec![121]) })) }))) }, layout: FunctionLayout { input_size: 32, selectors: 3, auxiliaries: 55, lookups: 31 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_167() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::EqZero(1), Op::Mul(2, 3)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 1 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_168() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 7, 8]), Op::Store(vec![9, 6, 10]), Op::Store(vec![9, 5, 11]), Op::Store(vec![9, 4, 12]), Op::Store(vec![9, 3, 13]), Op::Store(vec![9, 2, 14]), Op::Store(vec![9, 1, 15]), Op::Store(vec![9, 0, 16])], ctrl: Ctrl::Return(0, vec![17]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_169() -> Function { + Function { body: Block { ops: vec![Op::Call(168, vec![24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(168, vec![16, 17, 18, 19, 20, 21, 22, 23, 33], 1, false), Op::Call(168, vec![8, 9, 10, 11, 12, 13, 14, 15, 34], 1, false), Op::Call(168, vec![0, 1, 2, 3, 4, 5, 6, 7, 35], 1, false)], ctrl: Ctrl::Return(0, vec![36]) }, layout: FunctionLayout { input_size: 33, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_170() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Call(170, vec![4, 1], 1, false), Op::Call(168, vec![29, 30, 31, 32, 33, 34, 35, 36, 37], 1, false), Op::Call(168, vec![21, 22, 23, 24, 25, 26, 27, 28, 38], 1, false), Op::Call(168, vec![13, 14, 15, 16, 17, 18, 19, 20, 39], 1, false), Op::Call(168, vec![5, 6, 7, 8, 9, 10, 11, 12, 40], 1, false)], ctrl: Ctrl::Return(1, vec![41]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 41, lookups: 8 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_171() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(171, vec![4, 1], 1, false), Op::Call(168, vec![3, 5, 5, 5, 5, 5, 5, 5, 6], 1, false)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_172() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Const(G::from_u64(0)), Op::Store(vec![38, 38, 38, 38, 38, 38, 38, 38]), Op::Store(vec![5, 6, 7, 8, 9, 10, 5, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36]), Op::Call(75, vec![0, 37, 38, 38, 39, 40, 41], 1, false), Op::Call(74, vec![42], 32, false), Op::Call(105, vec![71, 72, 73, 74, 37], 1, false), Op::Call(105, vec![67, 68, 69, 70, 75], 1, false), Op::Call(105, vec![63, 64, 65, 66, 76], 1, false), Op::Call(105, vec![59, 60, 61, 62, 77], 1, false), Op::Call(105, vec![55, 56, 57, 58, 78], 1, false), Op::Call(105, vec![51, 52, 53, 54, 79], 1, false), Op::Call(105, vec![47, 48, 49, 50, 80], 1, false), Op::Call(105, vec![43, 44, 45, 46, 81], 1, false), Op::Call(126, vec![82, 37], 1, false), Op::Load(3, 83)], ctrl: Ctrl::Match(84, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 89)], ctrl: Ctrl::Match(90, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 92)], ctrl: Ctrl::Match(93, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 95)], ctrl: Ctrl::Match(96, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 98)], ctrl: Ctrl::Match(99, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 101)], ctrl: Ctrl::Match(102, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 104)], ctrl: Ctrl::Match(105, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![85, 88, 91, 94, 97, 100, 103, 106, 82, 107]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 6, 9, 12, 15, 18, 21, 24, 0, 25]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_173() -> Function { + Function { body: Block { ops: vec![Op::Call(172, vec![0, 1], 10, false), Op::Const(G::from_u64(1020)), Op::Sub(9, 12), Op::Add(8, 13), Op::Add(7, 14), Op::Add(6, 15), Op::EqZero(16), Op::Add(4, 5), Op::Add(3, 18), Op::Add(2, 19), Op::EqZero(20), Op::Const(G::from_u64(1)), Op::Sub(22, 21), Op::Mul(17, 23), Op::Sub(22, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(173, vec![10, 11], 10, false)], ctrl: Ctrl::Return(1, vec![26, 27, 28, 29, 30, 31, 32, 33, 34, 35]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 27, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_174() -> Function { + Function { body: Block { ops: vec![Op::Call(173, vec![0, 1], 10, false), Op::Call(173, vec![10, 11], 10, false)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 21, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_175() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(175, vec![4, 7], 1, false), Op::Store(vec![5, 3, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_176() -> Function { + Function { body: Block { ops: vec![Op::Call(172, vec![0, 1], 10, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4), Op::U8BitDecomposition(5), Op::U8BitDecomposition(6), Op::Const(G::from_u64(1)), Op::Store(vec![45, 45, 45]), Op::Call(168, vec![37, 38, 39, 40, 41, 42, 43, 44, 46], 1, false), Op::Call(168, vec![29, 30, 31, 32, 33, 34, 35, 36, 47], 1, false), Op::Call(168, vec![21, 22, 23, 24, 25, 26, 27, 28, 48], 1, false), Op::Call(168, vec![13, 14, 15, 16, 17, 18, 19, 20, 49], 1, false), Op::Call(175, vec![50, 2], 1, false)], ctrl: Ctrl::Return(0, vec![51, 11, 12]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 49, lookups: 12 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_177() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(168, vec![1, 2, 3, 4, 5, 6, 7, 8, 10], 1, false), Op::Call(243, vec![0, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_178() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(170, vec![1, 3], 1, false), Op::Call(243, vec![0, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_179() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![1, 14, 0]), Op::Store(vec![1, 13, 15]), Op::Store(vec![1, 12, 16]), Op::Store(vec![1, 11, 17]), Op::Store(vec![1, 10, 18]), Op::Store(vec![1, 9, 19]), Op::Store(vec![1, 5, 20]), Op::Store(vec![1, 8, 21]), Op::Store(vec![1, 7, 22]), Op::Store(vec![1, 6, 23]), Op::Store(vec![1, 5, 24]), Op::Store(vec![1, 4, 25]), Op::Store(vec![1, 3, 26]), Op::Store(vec![1, 2, 27])], ctrl: Ctrl::Return(0, vec![28]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 15, lookups: 15 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_180() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(180, vec![11, 1], 1, false), Op::Call(168, vec![3, 4, 5, 6, 7, 8, 9, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_181() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_182() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Mul(0, 0), Op::Const(G::from_u64(7)), Op::Mul(1, 1), Op::Mul(4, 5), Op::Add(3, 6), Op::Mul(0, 1), Op::Mul(1, 0), Op::Add(8, 9), Op::Const(G::from_u64(1)), Op::Sub(2, 11), Op::Call(182, vec![7, 10, 12], 2, false)], ctrl: Ctrl::Return(1, vec![13, 14]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 8, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_183() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1753635133440165772))], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(0, 1), Op::Call(183, vec![2], 1, false), Op::Mul(3, 3)], ctrl: Ctrl::Return(2, vec![4]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_184() -> Function { + Function { body: Block { ops: vec![Op::Call(182, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6)], ctrl: Ctrl::Return(0, vec![7, 8]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_185() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Sub(0, 2), Op::Call(185, vec![3], 1, false), Op::Mul(1, 4)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_186() -> Function { + Function { body: Block { ops: vec![Op::Call(182, vec![0, 1, 2], 2, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Sub(3, 5), Op::Sub(4, 6), Op::Call(183, vec![2], 1, false), Op::UnconstrainedGInverse(9), Op::Mul(9, 10), Op::Sub(11, 5), Op::Mul(9, 12), Op::AssertEq(vec![13], vec![6], None), Op::Mul(10, 12), Op::AssertEq(vec![14], vec![6], None), Op::Sub(0, 5), Op::Sub(1, 6), Op::Mul(15, 15), Op::Const(G::from_u64(7)), Op::Mul(16, 16), Op::Mul(18, 19), Op::Sub(17, 20), Op::UnconstrainedGInverse(21), Op::Mul(21, 22), Op::Sub(23, 5), Op::Mul(21, 24), Op::AssertEq(vec![25], vec![6], None), Op::Mul(22, 24), Op::AssertEq(vec![26], vec![6], None), Op::Mul(15, 22), Op::Sub(6, 16), Op::Mul(28, 22), Op::Mul(7, 27), Op::Mul(8, 29), Op::Mul(18, 31), Op::Add(30, 32), Op::Mul(7, 29), Op::Mul(8, 27), Op::Add(34, 35), Op::Sub(0, 10), Op::Mul(37, 37), Op::Sub(38, 20), Op::UnconstrainedGInverse(39), Op::Mul(39, 40), Op::Sub(41, 5), Op::Mul(39, 42), Op::AssertEq(vec![43], vec![6], None), Op::Mul(40, 42), Op::AssertEq(vec![44], vec![6], None), Op::Mul(37, 40), Op::Mul(28, 40), Op::Mul(7, 45), Op::Mul(8, 46), Op::Mul(18, 48), Op::Add(47, 49), Op::Mul(7, 46), Op::Mul(8, 45), Op::Add(51, 52), Op::Mul(7, 7), Op::Mul(8, 8), Op::Mul(18, 55), Op::Sub(54, 56), Op::UnconstrainedGInverse(57), Op::Mul(57, 58), Op::Sub(59, 5), Op::Mul(57, 60), Op::AssertEq(vec![61], vec![6], None), Op::Mul(58, 60), Op::AssertEq(vec![62], vec![6], None), Op::Mul(7, 58), Op::Sub(6, 8), Op::Mul(64, 58)], ctrl: Ctrl::Return(0, vec![33, 36, 50, 53, 37, 16, 63, 65]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 39, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_187() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 2), Op::Const(G::from_u64(7)), Op::Mul(1, 3), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(0, 3), Op::Mul(1, 2), Op::Add(11, 12), Op::Add(10, 4), Op::Add(13, 5)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_188() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Mul(2, 4), Op::Const(G::from_u64(7)), Op::Mul(3, 5), Op::Mul(7, 8), Op::Add(6, 9), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(11, 12), Op::Add(0, 10), Op::Add(1, 13)], ctrl: Ctrl::Return(0, vec![14, 15]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_189() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5, 5])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(188, vec![2, 3, 6, 7], 2, false), Op::Call(189, vec![8], 1, false), Op::Store(vec![9, 10, 11, 12])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_190() -> Function { + Function { body: Block { ops: vec![Op::Call(248, vec![0, 1], 4, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![16, 19]) }), (G::from_u64(1), Block { ops: vec![Op::Add(16, 17), Op::Add(16, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(250, vec![4, 18], 2, false)], ctrl: Ctrl::Return(1, vec![21, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Call(250, vec![5, 18], 2, false)], ctrl: Ctrl::Return(2, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(250, vec![2, 18], 2, false)], ctrl: Ctrl::Return(3, vec![21, 22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(250, vec![3, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }), (G::from_u64(4), Block { ops: vec![Op::Call(250, vec![6, 18], 2, false)], ctrl: Ctrl::Return(5, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(250, vec![7, 18], 2, false)], ctrl: Ctrl::Return(6, vec![21, 22]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(250, vec![8, 16], 2, false)], ctrl: Ctrl::Return(7, vec![19, 20]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(8, vec![9, 10]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![11, 12]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(10, vec![13, 14]) }), (G::from_u64(6), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(190, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Add(19, 21), Op::Add(20, 22)], ctrl: Ctrl::Return(11, vec![23, 24]) }), (G::from_u64(7), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(190, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Sub(19, 21), Op::Sub(20, 22)], ctrl: Ctrl::Return(12, vec![23, 24]) }), (G::from_u64(8), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(190, vec![0, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Mul(19, 21), Op::Const(G::from_u64(7)), Op::Mul(20, 22), Op::Mul(24, 25), Op::Add(23, 26), Op::Mul(19, 22), Op::Mul(20, 21), Op::Add(28, 29)], ctrl: Ctrl::Return(13, vec![27, 30]) }), (G::from_u64(9), Block { ops: vec![Op::Call(190, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Const(G::from_u64(0)), Op::Sub(21, 19), Op::Sub(21, 20)], ctrl: Ctrl::Return(14, vec![22, 23]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_191() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(190, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Call(187, vec![0, 1, 2, 3, 22, 23], 2, false), Op::Call(191, vec![24, 25, 2, 3, 21, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_192() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 4), Op::Const(G::from_u64(7)), Op::Mul(1, 5), Op::Mul(9, 10), Op::Add(8, 11), Op::Mul(0, 5), Op::Mul(1, 4), Op::Add(13, 14), Op::Const(G::from_u64(0)), Op::Mul(2, 6), Op::Mul(3, 7), Op::Mul(9, 18), Op::Add(17, 19), Op::Mul(2, 7), Op::Mul(3, 6), Op::Add(21, 22), Op::Mul(9, 20), Op::Mul(16, 23), Op::Mul(9, 25), Op::Add(24, 26), Op::Mul(9, 23), Op::Mul(16, 20), Op::Add(28, 29), Op::Add(12, 27), Op::Add(15, 30), Op::Mul(0, 6), Op::Mul(1, 7), Op::Mul(9, 34), Op::Add(33, 35), Op::Mul(0, 7), Op::Mul(1, 6), Op::Add(37, 38), Op::Mul(2, 4), Op::Mul(3, 5), Op::Mul(9, 41), Op::Add(40, 42), Op::Mul(2, 5), Op::Mul(3, 4), Op::Add(44, 45), Op::Add(36, 43), Op::Add(39, 46)], ctrl: Ctrl::Return(0, vec![31, 32, 47, 48]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 17, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_193() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![22, 22, 22, 22]) }), (G::from_u64(0), Block { ops: vec![Op::Call(193, vec![21, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 4, false), Op::Call(192, vec![22, 23, 24, 25, 1, 2, 3, 4], 4, false), Op::Call(190, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Add(26, 30), Op::Add(27, 31)], ctrl: Ctrl::Return(1, vec![32, 33, 28, 29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 14, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_194() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(193, vec![46, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 4, false), Op::Add(48, 22), Op::Add(49, 23), Op::Add(50, 24), Op::Add(51, 25), Op::Call(190, vec![30, 45, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false), Op::Call(192, vec![14, 15, 16, 17, 52, 53, 54, 55], 4, false), Op::Mul(56, 10), Op::Const(G::from_u64(7)), Op::Mul(57, 11), Op::Mul(63, 64), Op::Add(62, 65), Op::Mul(56, 11), Op::Mul(57, 10), Op::Add(67, 68), Op::Add(58, 66), Op::Add(59, 69), Op::Mul(56, 12), Op::Mul(57, 13), Op::Mul(63, 73), Op::Add(72, 74), Op::Mul(56, 13), Op::Mul(57, 12), Op::Add(76, 77), Op::Add(60, 75), Op::Add(61, 78), Op::Call(192, vec![10, 11, 12, 13, 52, 53, 54, 55], 4, false), Op::Const(G::from_u64(1)), Op::Sub(85, 6), Op::Add(5, 86)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(250, vec![35, 88], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 91), Op::Add(7, 92), Op::Call(250, vec![35, 93], 2, false), Op::Const(G::from_u64(0)), Op::Call(250, vec![36, 96], 2, false), Op::Add(97, 18), Op::Add(98, 19), Op::Call(250, vec![36, 91], 2, false), Op::Add(101, 20), Op::Add(102, 21), Op::Sub(99, 89), Op::Sub(100, 90), Op::Sub(103, 94), Op::Sub(104, 95), Op::Call(192, vec![81, 82, 83, 84, 105, 106, 107, 108], 4, false), Op::Sub(109, 70), Op::Sub(110, 71), Op::Call(187, vec![0, 1, 2, 3, 113, 114], 2, false), Op::Sub(111, 79), Op::Sub(112, 80), Op::Call(187, vec![115, 116, 2, 3, 117, 118], 2, false)], ctrl: Ctrl::Return(1, vec![119, 120]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(8, 88)], ctrl: Ctrl::Match(89, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(250, vec![35, 90], 2, false), Op::Const(G::from_u64(1)), Op::Add(7, 93), Op::Add(7, 94), Op::Call(250, vec![35, 95], 2, false), Op::Const(G::from_u64(2)), Op::Add(7, 98), Op::Add(7, 99), Op::Call(250, vec![35, 100], 2, false), Op::Const(G::from_u64(3)), Op::Add(7, 103), Op::Add(7, 104), Op::Call(250, vec![35, 105], 2, false), Op::Sub(101, 91), Op::Sub(102, 92), Op::Sub(106, 96), Op::Sub(107, 97), Op::Call(192, vec![81, 82, 83, 84, 108, 109, 110, 111], 4, false), Op::Sub(112, 70), Op::Sub(113, 71), Op::Call(187, vec![0, 1, 2, 3, 116, 117], 2, false), Op::Sub(114, 79), Op::Sub(115, 80), Op::Call(187, vec![118, 119, 2, 3, 120, 121], 2, false), Op::Add(5, 93), Op::Const(G::from_u64(0)), Op::Call(194, vec![122, 123, 2, 3, 47, 124, 6, 94, 9, 9, 93, 125, 125, 125, 125, 125, 125, 125, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(2, vec![126, 127]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(5, 90), Op::Sub(8, 90), Op::Call(194, vec![0, 1, 2, 3, 47, 91, 6, 7, 92, 9, 81, 82, 83, 84, 70, 71, 79, 80, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false)], ctrl: Ctrl::Return(3, vec![93, 94]) }))) }))) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 44, selectors: 4, auxiliaries: 46, lookups: 14 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_195() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(191, vec![28, 28, 25, 26, 1, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false), Op::Sub(17, 15), Op::Sub(28, 28), Op::Mul(31, 27), Op::Const(G::from_u64(7)), Op::Mul(32, 28), Op::Mul(34, 35), Op::Add(33, 36), Op::Mul(31, 28), Op::Mul(32, 27), Op::Add(38, 39), Op::Mul(21, 37), Op::Mul(22, 40), Op::Mul(34, 42), Op::Add(41, 43), Op::Mul(21, 40), Op::Mul(22, 37), Op::Add(45, 46), Op::Sub(18, 16), Op::Mul(48, 27), Op::Add(49, 36), Op::Mul(48, 28), Op::Add(51, 39), Op::Mul(21, 50), Op::Mul(22, 52), Op::Mul(34, 54), Op::Add(53, 55), Op::Mul(21, 52), Op::Mul(22, 50), Op::Add(57, 58), Op::Load(4, 2)], ctrl: Ctrl::Match(60, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(250, vec![9, 64], 2, false), Op::Call(250, vec![8, 64], 2, false), Op::Sub(65, 67), Op::Sub(66, 68), Op::Add(69, 44), Op::Add(70, 47), Op::Call(187, vec![29, 30, 25, 26, 71, 72], 2, false), Op::Const(G::from_u64(1)), Op::Call(250, vec![9, 75], 2, false), Op::Call(250, vec![8, 75], 2, false), Op::Sub(76, 78), Op::Sub(77, 79), Op::Add(80, 56), Op::Add(81, 59), Op::Call(187, vec![73, 74, 25, 26, 82, 83], 2, false)], ctrl: Ctrl::Return(0, vec![84, 85]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(242, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::Call(194, vec![29, 30, 25, 26, 2, 64, 65, 64, 3, 3, 66, 64, 64, 64, 64, 64, 64, 64, 44, 47, 56, 59, 11, 28, 12, 28, 13, 28, 14, 28, 0, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23, 24], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 28, selectors: 2, auxiliaries: 29, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_196() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![8, 7, 8, 10]), Op::Store(vec![8, 6, 8, 11]), Op::Store(vec![8, 5, 8, 12]), Op::Store(vec![8, 4, 8, 13]), Op::Store(vec![8, 3, 8, 14]), Op::Store(vec![8, 2, 8, 15]), Op::Store(vec![8, 1, 8, 16]), Op::Store(vec![8, 0, 8, 17])], ctrl: Ctrl::Return(0, vec![18]) }, layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 10, lookups: 10 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_197() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 9]) }), (G::from_u64(0), Block { ops: vec![Op::Mul(3, 6), Op::Const(G::from_u64(7)), Op::Mul(4, 7), Op::Mul(10, 11), Op::Add(9, 12), Op::Mul(3, 7), Op::Mul(4, 6), Op::Add(14, 15), Op::Mul(3, 1), Op::Mul(4, 2), Op::Mul(10, 18), Op::Add(17, 19), Op::Mul(3, 2), Op::Mul(4, 1), Op::Add(21, 22), Op::Call(197, vec![8, 1, 2, 20, 23], 2, false), Op::Add(13, 24), Op::Add(16, 25)], ctrl: Ctrl::Return(1, vec![26, 27]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 15, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_198() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(17, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(18, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 19, auxiliaries: 19, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_199() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(0, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(1, vec![5, 5]) }), (G::from_u64(1), Block { ops: vec![Op::Call(239, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(239, vec![4, 7], 1, false)], ctrl: Ctrl::Return(2, vec![6, 8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 4, lookups: 4 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_200() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![31]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(239, vec![2, 9], 1, false), Op::Const(G::from_u64(32)), Op::U8LessThan(31, 32), Op::Const(G::from_u64(1)), Op::AssertEq(vec![33], vec![34], None), Op::Call(198, vec![24], 1, false), Op::Call(250, vec![3, 9], 2, false), Op::Call(239, vec![4, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![38, 39], 1, false), Op::Call(239, vec![38, 34], 1, false), Op::Call(239, vec![5, 9], 1, false), Op::Call(239, vec![42, 39], 1, false), Op::Call(239, vec![42, 34], 1, false), Op::Call(250, vec![1, 9], 2, false)], ctrl: Ctrl::MatchContinue(45, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(1, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Yield(2, vec![48, 48]) }), (G::from_u64(1), Block { ops: vec![Op::Call(239, vec![7, 46], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![47, 48], 1, false), Op::Const(G::from_u64(1)), Op::Call(239, vec![47, 50], 1, false)], ctrl: Ctrl::Yield(3, vec![49, 51]) })].into_iter().collect(), None) })].into_iter().collect(), None, 2, 3, 3, Box::new(Block { ops: vec![Op::Call(242, vec![40], 1, false), Op::Sub(49, 27), Op::EqZero(50), Op::Const(G::from_u64(1)), Op::AssertEq(vec![51], vec![52], None), Op::Call(242, vec![41], 1, false), Op::Sub(53, 27), Op::EqZero(54), Op::AssertEq(vec![55], vec![52], None), Op::Call(242, vec![43], 1, false), Op::Sub(56, 29), Op::EqZero(57), Op::AssertEq(vec![58], vec![52], None), Op::Call(242, vec![44], 1, false), Op::Sub(59, 29), Op::EqZero(60), Op::AssertEq(vec![61], vec![52], None), Op::Call(242, vec![47], 1, false), Op::Sub(62, 28), Op::EqZero(63), Op::AssertEq(vec![64], vec![52], None), Op::Call(242, vec![48], 1, false), Op::Sub(65, 28), Op::EqZero(66), Op::AssertEq(vec![67], vec![52], None), Op::Call(182, vec![18, 19, 31], 2, false), Op::Const(G::from_u64(0)), Op::Sub(68, 52), Op::Sub(69, 70), Op::Call(183, vec![31], 1, false), Op::UnconstrainedGInverse(73), Op::Mul(73, 74), Op::Sub(75, 52), Op::Mul(73, 76), Op::AssertEq(vec![77], vec![70], None), Op::Mul(74, 76), Op::AssertEq(vec![78], vec![70], None), Op::Sub(18, 52), Op::Sub(19, 70), Op::Mul(79, 79), Op::Const(G::from_u64(7)), Op::Mul(80, 80), Op::Mul(82, 83), Op::Sub(81, 84), Op::UnconstrainedGInverse(85), Op::Mul(85, 86), Op::Sub(87, 52), Op::Mul(85, 88), Op::AssertEq(vec![89], vec![70], None), Op::Mul(86, 88), Op::AssertEq(vec![90], vec![70], None), Op::Mul(79, 86), Op::Sub(70, 80), Op::Mul(92, 86), Op::Mul(71, 91), Op::Mul(72, 93), Op::Mul(82, 95), Op::Add(94, 96), Op::Mul(71, 93), Op::Mul(72, 91), Op::Add(98, 99), Op::Sub(18, 74), Op::Mul(101, 101), Op::Sub(102, 84), Op::UnconstrainedGInverse(103), Op::Mul(103, 104), Op::Sub(105, 52), Op::Mul(103, 106), Op::AssertEq(vec![107], vec![70], None), Op::Mul(104, 106), Op::AssertEq(vec![108], vec![70], None), Op::Mul(101, 104), Op::Mul(92, 104), Op::Mul(71, 109), Op::Mul(72, 110), Op::Mul(82, 112), Op::Add(111, 113), Op::Mul(71, 110), Op::Mul(72, 109), Op::Add(115, 116), Op::Mul(71, 71), Op::Mul(72, 72), Op::Mul(82, 119), Op::Sub(118, 120), Op::UnconstrainedGInverse(121), Op::Mul(121, 122), Op::Sub(123, 52), Op::Mul(121, 124), Op::AssertEq(vec![125], vec![70], None), Op::Mul(122, 124), Op::AssertEq(vec![126], vec![70], None), Op::Mul(71, 122), Op::Sub(70, 72), Op::Mul(128, 122), Op::Store(vec![52, 52, 52, 52]), Op::Store(vec![70, 37, 70, 130]), Op::Store(vec![70, 36, 70, 131]), Op::Store(vec![70, 11, 70, 132]), Op::Store(vec![70, 10, 70, 133]), Op::Store(vec![70, 15, 70, 134]), Op::Store(vec![70, 14, 70, 135]), Op::Store(vec![70, 13, 70, 136]), Op::Store(vec![70, 12, 70, 137]), Op::Call(185, vec![31], 1, false), Op::Call(183, vec![31], 1, false), Op::Mul(139, 140), Op::UnconstrainedGInverse(141), Op::Mul(141, 142), Op::Sub(143, 52), Op::Mul(141, 144), Op::AssertEq(vec![145], vec![70], None), Op::Mul(142, 144), Op::AssertEq(vec![146], vec![70], None), Op::Call(191, vec![70, 70, 16, 17, 23, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false), Op::Sub(36, 10), Op::Sub(70, 70), Op::Mul(149, 142), Op::Mul(150, 70), Op::Mul(82, 152), Op::Add(151, 153), Op::Mul(149, 70), Op::Mul(150, 142), Op::Add(155, 156), Op::Mul(114, 154), Op::Mul(117, 157), Op::Mul(82, 159), Op::Add(158, 160), Op::Mul(114, 157), Op::Mul(117, 154), Op::Add(162, 163), Op::Sub(37, 11), Op::Mul(165, 142), Op::Add(166, 153), Op::Mul(165, 70), Op::Add(168, 156), Op::Mul(114, 167), Op::Mul(117, 169), Op::Mul(82, 171), Op::Add(170, 172), Op::Mul(114, 169), Op::Mul(117, 167), Op::Add(174, 175), Op::Load(4, 25)], ctrl: Ctrl::MatchContinue(177, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(250, vec![44, 181], 2, false), Op::Call(250, vec![43, 181], 2, false), Op::Sub(182, 184), Op::Sub(183, 185), Op::Add(186, 161), Op::Add(187, 164), Op::Call(187, vec![147, 148, 16, 17, 188, 189], 2, false), Op::Const(G::from_u64(1)), Op::Call(250, vec![44, 192], 2, false), Op::Call(250, vec![43, 192], 2, false), Op::Sub(193, 195), Op::Sub(194, 196), Op::Add(197, 173), Op::Add(198, 176), Op::Call(187, vec![190, 191, 16, 17, 199, 200], 2, false)], ctrl: Ctrl::Yield(4, vec![201, 202]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(242, vec![25], 1, false), Op::Const(G::from_u64(1)), Op::Call(194, vec![147, 148, 16, 17, 25, 181, 182, 181, 26, 26, 183, 181, 181, 181, 181, 181, 181, 181, 161, 164, 173, 176, 12, 70, 13, 70, 14, 70, 15, 70, 21, 40, 41, 47, 48, 43, 44, 138, 97, 100, 114, 117, 101, 80], 2, false)], ctrl: Ctrl::Yield(5, vec![184, 185]) })].into_iter().collect(), None, 2, 12, 6, Box::new(Block { ops: vec![Op::Call(239, vec![8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(239, vec![183, 184], 1, false), Op::Call(189, vec![185], 1, false), Op::Call(242, vec![186], 1, false), Op::Sub(187, 35), Op::EqZero(188), Op::Const(G::from_u64(1)), Op::AssertEq(vec![189], vec![190], None), Op::Call(182, vec![18, 19, 31], 2, false), Op::Call(197, vec![186, 191, 192, 190, 184], 2, false), Op::Mul(181, 127), Op::Const(G::from_u64(7)), Op::Mul(182, 129), Op::Mul(196, 197), Op::Add(195, 198), Op::Mul(181, 129), Op::Mul(182, 127), Op::Add(200, 201), Op::Sub(199, 193), Op::EqZero(203), Op::Sub(202, 194), Op::EqZero(205), Op::Mul(204, 206), Op::AssertEq(vec![207], vec![190], None), Op::Add(9, 190), Op::Call(200, vec![30, 1, 2, 3, 4, 5, 6, 7, 8, 208, 36, 37, 12, 13, 14, 15, 16, 17, 18, 19], 1, false)], ctrl: Ctrl::Return(6, vec![209]) })) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 20, selectors: 7, auxiliaries: 152, lookups: 50 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_201() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![13, 13]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(13, 5), Op::Const(G::from_u64(65536)), Op::Mul(15, 6), Op::Const(G::from_u64(16777216)), Op::Mul(17, 7), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 8), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 9), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 10), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 11), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(4, 32), Op::Const(G::from_u64(0)), Op::Call(201, vec![0, 1, 12], 2, false), Op::Mul(0, 35), Op::Const(G::from_u64(7)), Op::Mul(1, 36), Op::Mul(38, 39), Op::Add(37, 40), Op::Mul(0, 36), Op::Mul(1, 35), Op::Add(42, 43), Op::Add(33, 41), Op::Add(34, 44)], ctrl: Ctrl::Return(1, vec![45, 46]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 17, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_202() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(201, vec![5, 6, 8], 2, false), Op::Add(3, 10), Op::Add(4, 11), Op::Mul(12, 12), Op::Const(G::from_u64(7)), Op::Mul(13, 13), Op::Mul(15, 16), Op::Sub(14, 17), Op::UnconstrainedGInverse(18), Op::Mul(18, 19), Op::Const(G::from_u64(1)), Op::Sub(20, 21), Op::Mul(18, 22), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], None), Op::Mul(19, 22), Op::AssertEq(vec![25], vec![24], None), Op::Mul(12, 19), Op::Sub(24, 13), Op::Mul(27, 19), Op::Add(0, 26), Op::Add(1, 28), Op::Call(202, vec![29, 30, 9, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![31, 32]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_203() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 4), Op::Mul(2, 5), Op::Const(G::from_u64(0)), Op::AssertEq(vec![6], vec![7], None), Op::Call(203, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_204() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Call(204, vec![12, 15], 1, false)], ctrl: Ctrl::Return(1, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(204, vec![12, 15], 1, false), Op::Store(vec![16, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17])], ctrl: Ctrl::Return(2, vec![18]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_205() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6])], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(205, vec![5, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(205, vec![5, 8], 1, false), Op::Store(vec![9, 3, 4, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_206() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(2, 3), Op::U8RangeCheck(4, 5), Op::U8RangeCheck(6, 7), Op::U8RangeCheck(8, 9), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Const(G::from_u64(65536)), Op::Mul(12, 4), Op::Const(G::from_u64(16777216)), Op::Mul(14, 5), Op::Const(G::from_u64(4294967296)), Op::Mul(16, 6), Op::Const(G::from_u64(1099511627776)), Op::Mul(18, 7), Op::Const(G::from_u64(281474976710656)), Op::Mul(20, 8), Op::Const(G::from_u64(72057594037927936)), Op::Mul(22, 9), Op::Add(21, 23), Op::Add(19, 24), Op::Add(17, 25), Op::Add(15, 26), Op::Add(13, 27), Op::Add(11, 28), Op::Add(2, 29), Op::AssertEq(vec![30], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(9, 31), Op::Add(8, 32), Op::Add(7, 33), Op::Add(6, 34), Op::EqZero(35), Op::Add(4, 5), Op::Add(3, 37), Op::Add(2, 38), Op::EqZero(39), Op::Const(G::from_u64(1)), Op::Sub(41, 40), Op::Mul(36, 42), Op::Sub(41, 43), Op::AssertEq(vec![44], vec![41], None), Op::Call(168, vec![2, 3, 4, 5, 6, 7, 8, 9, 1], 1, false)], ctrl: Ctrl::Return(0, vec![45]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_207() -> Function { + Function { body: Block { ops: vec![Op::Call(241, vec![0], 1, false), Op::Call(208, vec![0, 1], 1, false), Op::Call(206, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_208() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(246, vec![3], 1, false), Op::Call(208, vec![4, 1], 1, false), Op::Call(180, vec![3, 6], 1, false), Op::Call(206, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_209() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![2], 1, false), Op::Call(207, vec![3, 4], 1, false), Op::Call(171, vec![2, 6], 1, false), Op::Call(206, vec![5, 7], 1, false), Op::Call(170, vec![1, 8], 1, false), Op::Call(171, vec![0, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_210() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(210, vec![7, 1], 1, false), Op::Call(209, vec![3, 4, 5, 6, 8], 1, false)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_211() -> Function { + Function { body: Block { ops: vec![Op::Call(247, vec![0], 1, false), Op::Call(212, vec![0, 1], 1, false), Op::Call(206, vec![2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_212() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(246, vec![3], 1, false), Op::Call(212, vec![12, 1], 1, false), Op::Call(168, vec![4, 5, 6, 7, 8, 9, 10, 11, 14], 1, false), Op::Call(180, vec![3, 15], 1, false), Op::Call(206, vec![13, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_213() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(211, vec![3, 5], 1, false), Op::Call(210, vec![2, 6], 1, false), Op::Call(244, vec![2], 1, false), Op::Call(206, vec![8, 7], 1, false), Op::Call(170, vec![1, 9], 1, false), Op::Call(180, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(117)), Op::Const(G::from_u64(108)), Op::Const(G::from_u64(116)), Op::Const(G::from_u64(105)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(115)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(107)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(118)), Op::Const(G::from_u64(48)), Op::Store(vec![12, 25, 11]), Op::Store(vec![12, 24, 26]), Op::Store(vec![12, 23, 27]), Op::Store(vec![12, 22, 28]), Op::Store(vec![12, 21, 29]), Op::Store(vec![12, 20, 30]), Op::Store(vec![12, 16, 31]), Op::Store(vec![12, 19, 32]), Op::Store(vec![12, 18, 33]), Op::Store(vec![12, 17, 34]), Op::Store(vec![12, 16, 35]), Op::Store(vec![12, 15, 36]), Op::Store(vec![12, 14, 37]), Op::Store(vec![12, 13, 38]), Op::Call(174, vec![39, 5], 18, false), Op::Call(168, vec![48, 49, 50, 51, 52, 53, 54, 55, 5], 1, false), Op::Call(168, vec![40, 41, 42, 43, 44, 45, 46, 47, 58], 1, false), Op::Call(243, vec![56, 59], 1, false), Op::Call(174, vec![60, 5], 18, false), Op::Call(168, vec![69, 70, 71, 72, 73, 74, 75, 76, 5], 1, false), Op::Call(168, vec![61, 62, 63, 64, 65, 66, 67, 68, 79], 1, false), Op::Call(243, vec![77, 80], 1, false), Op::Const(G::from_u64(256)), Op::Mul(82, 41), Op::Const(G::from_u64(65536)), Op::Mul(84, 42), Op::Const(G::from_u64(16777216)), Op::Mul(86, 43), Op::Const(G::from_u64(4294967296)), Op::Mul(88, 44), Op::Const(G::from_u64(1099511627776)), Op::Mul(90, 45), Op::Const(G::from_u64(281474976710656)), Op::Mul(92, 46), Op::Const(G::from_u64(72057594037927936)), Op::Mul(94, 47), Op::Add(93, 95), Op::Add(91, 96), Op::Add(89, 97), Op::Add(87, 98), Op::Add(85, 99), Op::Add(83, 100), Op::Add(40, 101), Op::Mul(82, 49), Op::Mul(84, 50), Op::Mul(86, 51), Op::Mul(88, 52), Op::Mul(90, 53), Op::Mul(92, 54), Op::Mul(94, 55), Op::Add(108, 109), Op::Add(107, 110), Op::Add(106, 111), Op::Add(105, 112), Op::Add(104, 113), Op::Add(103, 114), Op::Add(48, 115), Op::Mul(82, 62), Op::Mul(84, 63), Op::Mul(86, 64), Op::Mul(88, 65), Op::Mul(90, 66), Op::Mul(92, 67), Op::Mul(94, 68), Op::Add(122, 123), Op::Add(121, 124), Op::Add(120, 125), Op::Add(119, 126), Op::Add(118, 127), Op::Add(117, 128), Op::Add(61, 129), Op::Mul(82, 70), Op::Mul(84, 71), Op::Mul(86, 72), Op::Mul(88, 73), Op::Mul(90, 74), Op::Mul(92, 75), Op::Mul(94, 76), Op::Add(136, 137), Op::Add(135, 138), Op::Add(134, 139), Op::Add(133, 140), Op::Add(132, 141), Op::Add(131, 142), Op::Add(69, 143)], ctrl: Ctrl::Return(0, vec![102, 116, 130, 144, 81]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_214() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::U8RangeCheck(11, 12), Op::Const(G::from_u64(256)), Op::Mul(13, 6), Op::Const(G::from_u64(65536)), Op::Mul(15, 7), Op::Const(G::from_u64(16777216)), Op::Mul(17, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(25, 12), Op::Add(24, 26), Op::Add(22, 27), Op::Add(20, 28), Op::Add(18, 29), Op::Add(16, 30), Op::Add(14, 31), Op::Add(5, 32), Op::AssertEq(vec![33], vec![1], None), Op::Const(G::from_u64(1020)), Op::Sub(12, 34), Op::Add(11, 35), Op::Add(10, 36), Op::Add(9, 37), Op::EqZero(38), Op::Add(7, 8), Op::Add(6, 40), Op::Add(5, 41), Op::EqZero(42), Op::Const(G::from_u64(1)), Op::Sub(44, 43), Op::Mul(39, 45), Op::Sub(44, 46), Op::AssertEq(vec![47], vec![44], None), Op::Call(177, vec![0, 5, 6, 7, 8, 9, 10, 11, 12], 1, false), Op::Call(178, vec![48, 2], 1, false), Op::Store(vec![44, 44, 44]), Op::Call(131, vec![4, 50], 1, false), Op::Call(243, vec![49, 51], 1, false), Op::Call(174, vec![52, 50], 18, false), Op::Call(178, vec![69, 3], 1, false), Op::Call(174, vec![71, 50], 18, false), Op::Mul(13, 54), Op::Mul(15, 55), Op::Mul(17, 56), Op::Mul(19, 57), Op::Mul(21, 58), Op::Mul(23, 59), Op::Mul(25, 60), Op::Add(95, 96), Op::Add(94, 97), Op::Add(93, 98), Op::Add(92, 99), Op::Add(91, 100), Op::Add(90, 101), Op::Add(53, 102), Op::Mul(13, 62), Op::Mul(15, 63), Op::Mul(17, 64), Op::Mul(19, 65), Op::Mul(21, 66), Op::Mul(23, 67), Op::Mul(25, 68), Op::Add(109, 110), Op::Add(108, 111), Op::Add(107, 112), Op::Add(106, 113), Op::Add(105, 114), Op::Add(104, 115), Op::Add(61, 116), Op::Mul(13, 73), Op::Mul(15, 74), Op::Mul(17, 75), Op::Mul(19, 76), Op::Mul(21, 77), Op::Mul(23, 78), Op::Mul(25, 79), Op::Add(123, 124), Op::Add(122, 125), Op::Add(121, 126), Op::Add(120, 127), Op::Add(119, 128), Op::Add(118, 129), Op::Add(72, 130), Op::Mul(13, 81), Op::Mul(15, 82), Op::Mul(17, 83), Op::Mul(19, 84), Op::Mul(21, 85), Op::Mul(23, 86), Op::Mul(25, 87), Op::Add(137, 138), Op::Add(136, 139), Op::Add(135, 140), Op::Add(134, 141), Op::Add(133, 142), Op::Add(132, 143), Op::Add(80, 144)], ctrl: Ctrl::Return(0, vec![103, 117, 131, 145, 88]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_215() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::AssertEq(vec![3], vec![6], None), Op::Call(215, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_216() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(10, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12, 13, 14, 15, 16, 17, 18, 19, 20, 21], vec![22, 22, 22, 22, 22, 22, 22, 22, 22, 22], None)], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Load(10, 1)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(10, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![22], vec![23], None), Op::Call(216, vec![11, 21], 1, false)], ctrl: Ctrl::Return(1, vec![24]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_217() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(216, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], None), Op::Call(217, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_218() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 1), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5, 6, 7], vec![8, 8, 8], None)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(32, 3), Op::Load(32, 6), Op::Call(10, vec![8, 9, 10, 11, 12, 13, 14, 15, 40, 41, 42, 43, 44, 45, 46, 47], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![72], vec![73], None), Op::Call(10, vec![16, 17, 18, 19, 20, 21, 22, 23, 48, 49, 50, 51, 52, 53, 54, 55], 1, false), Op::AssertEq(vec![74], vec![73], None), Op::Call(10, vec![24, 25, 26, 27, 28, 29, 30, 31, 56, 57, 58, 59, 60, 61, 62, 63], 1, false), Op::AssertEq(vec![75], vec![73], None), Op::Call(10, vec![32, 33, 34, 35, 36, 37, 38, 39, 64, 65, 66, 67, 68, 69, 70, 71], 1, false), Op::AssertEq(vec![76], vec![73], None), Op::Call(218, vec![4, 7], 1, false)], ctrl: Ctrl::Return(1, vec![77]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_219() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(219, vec![4], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_220() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0, 1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(8, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![5, 6, 8], 2, false), Op::Add(3, 18), Op::Add(4, 19), Op::Mul(20, 20), Op::Const(G::from_u64(7)), Op::Mul(21, 21), Op::Mul(23, 24), Op::Sub(22, 25), Op::UnconstrainedGInverse(26), Op::Mul(26, 27), Op::Const(G::from_u64(1)), Op::Sub(28, 29), Op::Mul(26, 30), Op::Const(G::from_u64(0)), Op::AssertEq(vec![31], vec![32], None), Op::Mul(27, 30), Op::AssertEq(vec![33], vec![32], None), Op::Mul(20, 27), Op::Sub(32, 21), Op::Mul(35, 27), Op::Const(G::from_u64(256)), Op::Mul(37, 10), Op::Const(G::from_u64(65536)), Op::Mul(39, 11), Op::Const(G::from_u64(16777216)), Op::Mul(41, 12), Op::Const(G::from_u64(4294967296)), Op::Mul(43, 13), Op::Const(G::from_u64(1099511627776)), Op::Mul(45, 14), Op::Const(G::from_u64(281474976710656)), Op::Mul(47, 15), Op::Const(G::from_u64(72057594037927936)), Op::Mul(49, 16), Op::Add(48, 50), Op::Add(46, 51), Op::Add(44, 52), Op::Add(42, 53), Op::Add(40, 54), Op::Add(38, 55), Op::Add(9, 56), Op::Mul(34, 57), Op::Mul(36, 32), Op::Mul(23, 59), Op::Add(58, 60), Op::Mul(34, 32), Op::Mul(36, 57), Op::Add(62, 63), Op::Add(0, 61), Op::Add(1, 64), Op::Call(220, vec![65, 66, 17, 3, 4, 5, 6], 2, false)], ctrl: Ctrl::Return(1, vec![67, 68]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_221() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(28, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(29, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(30, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(31, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(32, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(33, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_222() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(221, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], None), Op::Call(222, vec![3], 1, false)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_223() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(223, vec![3], 1, false), Op::Add(2, 4)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_224() -> Function { + Function { body: Block { ops: vec![Op::EqZero(0), Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![2], None), Op::UnconstrainedGToBytes(0), Op::U8RangeCheck(3, 4), Op::U8RangeCheck(5, 6), Op::U8RangeCheck(7, 8), Op::U8RangeCheck(9, 10), Op::Const(G::from_u64(256)), Op::Mul(11, 4), Op::Const(G::from_u64(65536)), Op::Mul(13, 5), Op::Const(G::from_u64(16777216)), Op::Mul(15, 6), Op::Const(G::from_u64(4294967296)), Op::Mul(17, 7), Op::Const(G::from_u64(1099511627776)), Op::Mul(19, 8), Op::Const(G::from_u64(281474976710656)), Op::Mul(21, 9), Op::Const(G::from_u64(72057594037927936)), Op::Mul(23, 10), Op::Add(22, 24), Op::Add(20, 25), Op::Add(18, 26), Op::Add(16, 27), Op::Add(14, 28), Op::Add(12, 29), Op::Add(3, 30), Op::AssertEq(vec![31], vec![0], None), Op::Const(G::from_u64(1020)), Op::Sub(10, 32), Op::Add(9, 33), Op::Add(8, 34), Op::Add(7, 35), Op::EqZero(36), Op::Add(5, 6), Op::Add(4, 38), Op::Add(3, 39), Op::EqZero(40), Op::Const(G::from_u64(1)), Op::Sub(42, 41), Op::Mul(37, 43), Op::Sub(42, 44), Op::AssertEq(vec![45], vec![42], None), Op::Add(9, 10), Op::Add(8, 46), Op::Add(7, 47), Op::Add(6, 48), Op::AssertEq(vec![49], vec![2], None), Op::Sub(5, 42), Op::Mul(5, 50), Op::AssertEq(vec![51], vec![2], None), Op::Add(3, 4), Op::Mul(5, 52), Op::AssertEq(vec![53], vec![2], None)], ctrl: Ctrl::Return(0, vec![42]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_225() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 20)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Load(10, 30), Op::Const(G::from_u64(1)), Op::AssertEq(vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40], vec![41, 41, 41, 41, 41, 41, 41, 41, 41, 41], None)], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 27, 28, 29]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_226() -> Function { + Function { body: Block { ops: vec![Op::U8LessThan(0, 1), Op::Sub(0, 1), Op::EqZero(4), Op::Mul(5, 2), Op::Add(3, 6)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_227() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(226, vec![0, 8, 16], 1, false), Op::Call(226, vec![1, 9, 17], 1, false), Op::Call(226, vec![2, 10, 18], 1, false), Op::Call(226, vec![3, 11, 19], 1, false), Op::Call(226, vec![4, 12, 20], 1, false), Op::Call(226, vec![5, 13, 21], 1, false), Op::Call(226, vec![6, 14, 22], 1, false), Op::Call(226, vec![7, 15, 23], 1, false)], ctrl: Ctrl::Return(0, vec![24]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_228() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(0), Block { ops: vec![Op::Load(11, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(25, 6), Op::Const(G::from_u64(65536)), Op::Mul(27, 7), Op::Const(G::from_u64(16777216)), Op::Mul(29, 8), Op::Const(G::from_u64(4294967296)), Op::Mul(31, 9), Op::Const(G::from_u64(1099511627776)), Op::Mul(33, 10), Op::Const(G::from_u64(281474976710656)), Op::Mul(35, 11), Op::Const(G::from_u64(72057594037927936)), Op::Mul(37, 12), Op::Add(36, 38), Op::Add(34, 39), Op::Add(32, 40), Op::Add(30, 41), Op::Add(28, 42), Op::Add(26, 43), Op::Add(5, 44), Op::Const(G::from_u64(1)), Op::Add(45, 46), Op::Const(G::from_u64(0)), Op::AssertEq(vec![47], vec![48], None), Op::Mul(25, 17), Op::Mul(27, 18), Op::Mul(29, 19), Op::Mul(31, 20), Op::Mul(33, 21), Op::Mul(35, 22), Op::Mul(37, 23), Op::Add(54, 55), Op::Add(53, 56), Op::Add(52, 57), Op::Add(51, 58), Op::Add(50, 59), Op::Add(49, 60), Op::Add(16, 61), Op::AssertEq(vec![62], vec![46], None), Op::Call(225, vec![4], 24, false), Op::Call(225, vec![15], 24, false), Op::Mul(25, 64), Op::Mul(27, 65), Op::Mul(29, 66), Op::Mul(31, 67), Op::Mul(33, 68), Op::Mul(35, 69), Op::Mul(37, 70), Op::Add(116, 117), Op::Add(115, 118), Op::Add(114, 119), Op::Add(113, 120), Op::Add(112, 121), Op::Add(111, 122), Op::Add(63, 123), Op::Const(G::from_u64(16)), Op::AssertEq(vec![124], vec![125], None), Op::Mul(25, 88), Op::Mul(27, 89), Op::Mul(29, 90), Op::Mul(31, 91), Op::Mul(33, 92), Op::Mul(35, 93), Op::Mul(37, 94), Op::Add(131, 132), Op::Add(130, 133), Op::Add(129, 134), Op::Add(128, 135), Op::Add(127, 136), Op::Add(126, 137), Op::Add(87, 138), Op::AssertEq(vec![139], vec![125], None), Op::Mul(25, 72), Op::Mul(27, 73), Op::Mul(29, 74), Op::Mul(31, 75), Op::Mul(33, 76), Op::Mul(35, 77), Op::Mul(37, 78), Op::Add(145, 146), Op::Add(144, 147), Op::Add(143, 148), Op::Add(142, 149), Op::Add(141, 150), Op::Add(140, 151), Op::Add(71, 152), Op::Mul(25, 96), Op::Mul(27, 97), Op::Mul(29, 98), Op::Mul(31, 99), Op::Mul(33, 100), Op::Mul(35, 101), Op::Mul(37, 102), Op::Add(159, 160), Op::Add(158, 161), Op::Add(157, 162), Op::Add(156, 163), Op::Add(155, 164), Op::Add(154, 165), Op::Add(95, 166), Op::AssertEq(vec![167], vec![153], None), Op::Mul(25, 80), Op::Mul(27, 81), Op::Mul(29, 82), Op::Mul(31, 83), Op::Mul(33, 84), Op::Mul(35, 85), Op::Mul(37, 86), Op::Add(173, 174), Op::Add(172, 175), Op::Add(171, 176), Op::Add(170, 177), Op::Add(169, 178), Op::Add(168, 179), Op::Add(79, 180), Op::Mul(25, 104), Op::Mul(27, 105), Op::Mul(29, 106), Op::Mul(31, 107), Op::Mul(33, 108), Op::Mul(35, 109), Op::Mul(37, 110), Op::Add(187, 188), Op::Add(186, 189), Op::Add(185, 190), Op::Add(184, 191), Op::Add(183, 192), Op::Add(182, 193), Op::Add(103, 194), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(196, 197), Op::U8RangeCheck(198, 199), Op::U8RangeCheck(200, 201), Op::U8RangeCheck(202, 203), Op::Mul(25, 197), Op::Mul(27, 198), Op::Mul(29, 199), Op::Mul(31, 200), Op::Mul(33, 201), Op::Mul(35, 202), Op::Mul(37, 203), Op::Add(209, 210), Op::Add(208, 211), Op::Add(207, 212), Op::Add(206, 213), Op::Add(205, 214), Op::Add(204, 215), Op::Add(196, 216), Op::AssertEq(vec![217], vec![181], None), Op::Const(G::from_u64(1020)), Op::Sub(203, 218), Op::Add(202, 219), Op::Add(201, 220), Op::Add(200, 221), Op::EqZero(222), Op::Add(198, 199), Op::Add(197, 224), Op::Add(196, 225), Op::EqZero(226), Op::Sub(46, 227), Op::Mul(223, 228), Op::Sub(46, 229), Op::AssertEq(vec![230], vec![46], None), Op::UnconstrainedGToBytes(195), Op::U8RangeCheck(231, 232), Op::U8RangeCheck(233, 234), Op::U8RangeCheck(235, 236), Op::U8RangeCheck(237, 238), Op::Mul(25, 232), Op::Mul(27, 233), Op::Mul(29, 234), Op::Mul(31, 235), Op::Mul(33, 236), Op::Mul(35, 237), Op::Mul(37, 238), Op::Add(244, 245), Op::Add(243, 246), Op::Add(242, 247), Op::Add(241, 248), Op::Add(240, 249), Op::Add(239, 250), Op::Add(231, 251), Op::AssertEq(vec![252], vec![195], None), Op::Sub(238, 218), Op::Add(237, 253), Op::Add(236, 254), Op::Add(235, 255), Op::EqZero(256), Op::Add(233, 234), Op::Add(232, 258), Op::Add(231, 259), Op::EqZero(260), Op::Sub(46, 261), Op::Mul(257, 262), Op::Sub(46, 263), Op::AssertEq(vec![264], vec![46], None), Op::Call(227, vec![196, 197, 198, 199, 200, 201, 202, 203, 231, 232, 233, 234, 235, 236, 237, 238], 1, false), Op::AssertEq(vec![265], vec![46], None), Op::Sub(153, 1), Op::EqZero(266), Op::UnconstrainedGToBytes(153), Op::U8RangeCheck(268, 269), Op::U8RangeCheck(270, 271), Op::U8RangeCheck(272, 273), Op::U8RangeCheck(274, 275), Op::Mul(25, 269), Op::Mul(27, 270), Op::Mul(29, 271), Op::Mul(31, 272), Op::Mul(33, 273), Op::Mul(35, 274), Op::Mul(37, 275), Op::Add(281, 282), Op::Add(280, 283), Op::Add(279, 284), Op::Add(278, 285), Op::Add(277, 286), Op::Add(276, 287), Op::Add(268, 288), Op::AssertEq(vec![289], vec![153], None), Op::Sub(275, 218), Op::Add(274, 290), Op::Add(273, 291), Op::Add(272, 292), Op::EqZero(293), Op::Add(270, 271), Op::Add(269, 295), Op::Add(268, 296), Op::EqZero(297), Op::Sub(46, 298), Op::Mul(294, 299), Op::Sub(46, 300), Op::AssertEq(vec![301], vec![46], None), Op::UnconstrainedGToBytes(1), Op::U8RangeCheck(302, 303), Op::U8RangeCheck(304, 305), Op::U8RangeCheck(306, 307), Op::U8RangeCheck(308, 309), Op::Mul(25, 303), Op::Mul(27, 304), Op::Mul(29, 305), Op::Mul(31, 306), Op::Mul(33, 307), Op::Mul(35, 308), Op::Mul(37, 309), Op::Add(315, 316), Op::Add(314, 317), Op::Add(313, 318), Op::Add(312, 319), Op::Add(311, 320), Op::Add(310, 321), Op::Add(302, 322), Op::AssertEq(vec![323], vec![1], None), Op::Sub(309, 218), Op::Add(308, 324), Op::Add(307, 325), Op::Add(306, 326), Op::EqZero(327), Op::Add(304, 305), Op::Add(303, 329), Op::Add(302, 330), Op::EqZero(331), Op::Sub(46, 332), Op::Mul(328, 333), Op::Sub(46, 334), Op::AssertEq(vec![335], vec![46], None), Op::Call(227, vec![268, 269, 270, 271, 272, 273, 274, 275, 302, 303, 304, 305, 306, 307, 308, 309], 1, false), Op::Sub(46, 336), Op::UnconstrainedGToBytes(2), Op::U8RangeCheck(338, 339), Op::U8RangeCheck(340, 341), Op::U8RangeCheck(342, 343), Op::U8RangeCheck(344, 345), Op::Mul(25, 339), Op::Mul(27, 340), Op::Mul(29, 341), Op::Mul(31, 342), Op::Mul(33, 343), Op::Mul(35, 344), Op::Mul(37, 345), Op::Add(351, 352), Op::Add(350, 353), Op::Add(349, 354), Op::Add(348, 355), Op::Add(347, 356), Op::Add(346, 357), Op::Add(338, 358), Op::AssertEq(vec![359], vec![2], None), Op::Sub(345, 218), Op::Add(344, 360), Op::Add(343, 361), Op::Add(342, 362), Op::EqZero(363), Op::Add(340, 341), Op::Add(339, 365), Op::Add(338, 366), Op::EqZero(367), Op::Sub(46, 368), Op::Mul(364, 369), Op::Sub(46, 370), Op::AssertEq(vec![371], vec![46], None), Op::UnconstrainedGToBytes(181), Op::U8RangeCheck(372, 373), Op::U8RangeCheck(374, 375), Op::U8RangeCheck(376, 377), Op::U8RangeCheck(378, 379), Op::Mul(25, 373), Op::Mul(27, 374), Op::Mul(29, 375), Op::Mul(31, 376), Op::Mul(33, 377), Op::Mul(35, 378), Op::Mul(37, 379), Op::Add(385, 386), Op::Add(384, 387), Op::Add(383, 388), Op::Add(382, 389), Op::Add(381, 390), Op::Add(380, 391), Op::Add(372, 392), Op::AssertEq(vec![393], vec![181], None), Op::Sub(379, 218), Op::Add(378, 394), Op::Add(377, 395), Op::Add(376, 396), Op::EqZero(397), Op::Add(374, 375), Op::Add(373, 399), Op::Add(372, 400), Op::EqZero(401), Op::Sub(46, 402), Op::Mul(398, 403), Op::Sub(46, 404), Op::AssertEq(vec![405], vec![46], None), Op::Call(227, vec![338, 339, 340, 341, 342, 343, 344, 345, 372, 373, 374, 375, 376, 377, 378, 379], 1, false), Op::Mul(267, 406), Op::Add(337, 407), Op::AssertEq(vec![408], vec![46], None), Op::Call(228, vec![24, 153, 195], 1, false)], ctrl: Ctrl::Return(1, vec![409]) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_229() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![1], vec![46], None), Op::AssertEq(vec![2], vec![46], None), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![47], None)], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(17, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(242, vec![21], 1, false), Op::EqZero(48), Op::Const(G::from_u64(0)), Op::AssertEq(vec![49], vec![50], None), Op::Call(241, vec![39], 1, false), Op::AssertEq(vec![51], vec![48], None), Op::Call(241, vec![40], 1, false), Op::AssertEq(vec![52], vec![48], None), Op::Call(241, vec![36], 1, false), Op::AssertEq(vec![53], vec![48], None), Op::Call(203, vec![17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![54], vec![55], None), Op::Call(241, vec![17], 1, false), Op::Call(247, vec![8], 1, false), Op::Sub(56, 57), Op::EqZero(58), Op::AssertEq(vec![59], vec![55], None), Op::Call(204, vec![8, 17], 1, false), Op::Call(205, vec![11, 17], 1, false), Op::Call(247, vec![60], 1, false), Op::Call(242, vec![21], 1, false), Op::Sub(62, 63), Op::EqZero(64), Op::AssertEq(vec![65], vec![55], None)], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(215, vec![12, 17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![66], vec![67], None), Op::Call(218, vec![13, 18], 1, false), Op::AssertEq(vec![68], vec![67], None), Op::Call(215, vec![14, 22], 1, false), Op::AssertEq(vec![69], vec![67], None), Op::Call(222, vec![22], 1, false), Op::AssertEq(vec![70], vec![67], None), Op::Call(223, vec![17], 1, false), Op::Call(241, vec![22], 1, false), Op::AssertEq(vec![71], vec![72], None)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![73, 73, 73])], ctrl: Ctrl::Yield(0, vec![74]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(214, vec![41, 16, 19, 20, 21], 5, false), Op::Const(G::from_u64(0)), Op::Call(202, vec![79, 79, 15, 42, 43, 44, 45], 2, false), Op::Call(200, vec![60, 61, 22, 21, 39, 40, 37, 38, 36, 79, 80, 81, 42, 43, 44, 45, 74, 75, 76, 77], 1, false), Op::Call(247, vec![60], 1, false)], ctrl: Ctrl::Match(23, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(241, vec![23], 1, false), Op::Call(246, vec![24], 1, false), Op::Sub(85, 84), Op::EqZero(86), Op::Const(G::from_u64(1)), Op::AssertEq(vec![87], vec![88], None), Op::Call(242, vec![25], 1, false), Op::Const(G::from_u64(3)), Op::Call(142, vec![37, 38], 1, false), Op::Add(90, 91), Op::AssertEq(vec![89], vec![92], None), Op::Call(252, vec![26], 1, false), Op::Sub(93, 84), Op::EqZero(94), Op::AssertEq(vec![95], vec![88], None), Op::Call(242, vec![27], 1, false), Op::AssertEq(vec![96], vec![88], None), Op::Store(vec![88, 88, 88])], ctrl: Ctrl::MatchContinue(37, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![97]) }), (G::from_u64(1), Block { ops: vec![Op::Call(133, vec![38, 97], 1, false)], ctrl: Ctrl::Yield(3, vec![98]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(133, vec![36, 98], 1, false), Op::Call(133, vec![40, 99], 1, false), Op::Call(133, vec![39, 100], 1, false), Op::Call(243, vec![78, 101], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![103, 103, 103]), Op::Call(174, vec![102, 104], 18, false), Op::Const(G::from_u64(256)), Op::Mul(123, 106), Op::Const(G::from_u64(65536)), Op::Mul(125, 107), Op::Const(G::from_u64(16777216)), Op::Mul(127, 108), Op::Const(G::from_u64(4294967296)), Op::Mul(129, 109), Op::Const(G::from_u64(1099511627776)), Op::Mul(131, 110), Op::Const(G::from_u64(281474976710656)), Op::Mul(133, 111), Op::Const(G::from_u64(72057594037927936)), Op::Mul(135, 112), Op::Add(134, 136), Op::Add(132, 137), Op::Add(130, 138), Op::Add(128, 139), Op::Add(126, 140), Op::Add(124, 141), Op::Add(105, 142), Op::Mul(123, 114), Op::Mul(125, 115), Op::Mul(127, 116), Op::Mul(129, 117), Op::Mul(131, 118), Op::Mul(133, 119), Op::Mul(135, 120), Op::Add(149, 150), Op::Add(148, 151), Op::Add(147, 152), Op::Add(146, 153), Op::Add(145, 154), Op::Add(144, 155), Op::Add(113, 156), Op::Call(137, vec![121, 23, 24, 5], 2, false), Op::Call(131, vec![27, 104], 1, false), Op::Call(243, vec![159, 160], 1, false), Op::Call(135, vec![161, 23], 1, false), Op::Call(136, vec![162, 28, 29, 30, 31, 32, 33, 34, 35, 6], 2, false), Op::Add(84, 0), Op::Const(G::from_u64(33)), Op::U32LessThan(165, 166), Op::AssertEq(vec![167], vec![103], None), Op::Call(158, vec![163, 164, 4, 165], 1, false), Op::Call(162, vec![25, 168, 18, 19, 20, 73, 37, 38, 61, 22, 83, 0, 165], 1, false), Op::AssertEq(vec![169], vec![103], None), Op::Const(G::from_u64(0)), Op::Call(161, vec![25, 26, 170, 4], 1, false), Op::Call(157, vec![163, 164, 171, 143, 157, 39, 40, 36, 37, 38, 18, 19, 20, 73, 61, 22, 76, 77, 83, 0, 165, 158, 23, 27, 84], 1, false), Op::Call(165, vec![26, 23, 172, 168, 170, 165], 1, false), Op::AssertEq(vec![173], vec![103], None), Op::Call(219, vec![21], 2, false)], ctrl: Ctrl::Return(4, vec![174, 175]) })) }))) })) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_230() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 12)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Load(26, 13), Op::Const(G::from_u64(1)), Op::AssertEq(vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53], vec![54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54], None)], ctrl: Ctrl::Return(0, vec![20, 21]) }), (G::from_u64(0), Block { ops: vec![Op::Load(26, 13)], ctrl: Ctrl::Match(28, [(G::from_u64(0), Block { ops: vec![Op::Call(229, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 23, 24, 25, 26, 14, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 15, 16, 17, 18, 19], 2, false), Op::Const(G::from_u64(1)), Op::Add(14, 56), Op::Add(20, 54), Op::Add(21, 55), Op::Call(230, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 27, 53, 57, 15, 16, 17, 18, 19, 58, 59], 2, false)], ctrl: Ctrl::Return(1, vec![60, 61]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_231() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(231, vec![6], 1, false), Op::Call(243, vec![5, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_232() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![12], 1, false), Op::Call(224, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None), Op::Call(240, vec![14], 1, false), Op::Call(244, vec![12], 1, false), Op::AssertEq(vec![18], vec![19], None), Op::Const(G::from_u64(0)), Op::Call(228, vec![13, 20, 20], 1, false), Op::AssertEq(vec![21], vec![17], None)], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22])], ctrl: Ctrl::Yield(0, vec![23]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), None, 1, 1, 1, Box::new(Block { ops: vec![Op::Call(213, vec![7, 22, 12, 13], 5, false), Op::Const(G::from_u64(0)), Op::Call(220, vec![28, 28, 13, 23, 24, 25, 26], 2, false), Op::Call(230, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 28, 27, 23, 24, 25, 26, 29, 30], 2, false), Op::EqZero(31), Op::EqZero(32), Op::Mul(33, 34), Op::Const(G::from_u64(1)), Op::AssertEq(vec![35], vec![36], None), Op::Call(231, vec![12], 1, false)], ctrl: Ctrl::Return(2, vec![37]) })) }))) }))) }, layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_233() -> Function { + Function { body: Block { ops: vec![Op::Call(29, vec![12], 2, false), Op::Call(63, vec![16, 15], 2, false), Op::Call(29, vec![18], 2, false), Op::Call(66, vec![20, 19], 2, false), Op::Call(29, vec![22], 2, false), Op::Call(68, vec![24, 23], 2, false), Op::Add(12, 13), Op::AssertEq(vec![26], vec![27], None), Op::Call(232, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25], 1, false), Op::Call(217, vec![28, 14], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![29], vec![30], None)], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 15, lookups: 9 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_234() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(235, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_235() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(237, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(235, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 4, 8])], ctrl: Ctrl::Return(1, vec![11, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_236() -> Function { + Function { body: Block { ops: vec![Op::Call(26, vec![0], 2, false), Op::Call(237, vec![2, 1], 2, false)], ctrl: Ctrl::Return(0, vec![3, 4]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: false } +} + +#[inline(never)] +fn expected_function_237() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(25, vec![0], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 11), Op::Call(237, vec![10, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 2, 3, 4, 5, 6, 7, 8, 9, 13])], ctrl: Ctrl::Return(1, vec![16, 14]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_238() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::IOGetInfo(16, vec![16]), Op::Const(G::from_u64(1)), Op::IOGetInfo(19, vec![16]), Op::Call(1, vec![19, 20, 21], 1, true), Op::Const(G::from_u64(103)), Op::Const(G::from_u64(230)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(106)), Op::Const(G::from_u64(133)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(187)), Op::Const(G::from_u64(114)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(110)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(245)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(165)), Op::Const(G::from_u64(127)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(104)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(155)), Op::Const(G::from_u64(171)), Op::Const(G::from_u64(217)), Op::Const(G::from_u64(131)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(205)), Op::Const(G::from_u64(224)), Op::Const(G::from_u64(91)), Op::Store(vec![19, 19, 19]), Op::Store(vec![16, 16, 16, 16, 16, 16, 16, 16]), Op::Store(vec![23, 24, 25, 26, 27, 28, 23, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53]), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19]), Op::Call(75, vec![22, 54, 16, 16, 55, 56, 57], 1, false), Op::Call(74, vec![58], 32, false), Op::Const(G::from_u64(256)), Op::Mul(91, 60), Op::Const(G::from_u64(65536)), Op::Mul(93, 61), Op::Const(G::from_u64(16777216)), Op::Mul(95, 62), Op::Add(94, 96), Op::Add(92, 97), Op::Add(59, 98), Op::Mul(91, 64), Op::Mul(93, 65), Op::Mul(95, 66), Op::Add(101, 102), Op::Add(100, 103), Op::Add(63, 104), Op::Mul(91, 68), Op::Mul(93, 69), Op::Mul(95, 70), Op::Add(107, 108), Op::Add(106, 109), Op::Add(67, 110), Op::Mul(91, 72), Op::Mul(93, 73), Op::Mul(95, 74), Op::Add(113, 114), Op::Add(112, 115), Op::Add(71, 116), Op::Mul(91, 76), Op::Mul(93, 77), Op::Mul(95, 78), Op::Add(119, 120), Op::Add(118, 121), Op::Add(75, 122), Op::Mul(91, 80), Op::Mul(93, 81), Op::Mul(95, 82), Op::Add(125, 126), Op::Add(124, 127), Op::Add(79, 128), Op::Mul(91, 84), Op::Mul(93, 85), Op::Mul(95, 86), Op::Add(131, 132), Op::Add(130, 133), Op::Add(83, 134), Op::Mul(91, 88), Op::Mul(93, 89), Op::Mul(95, 90), Op::Add(137, 138), Op::Add(136, 139), Op::Add(87, 140), Op::AssertEq(vec![99, 105, 111, 117, 123, 129, 135, 141], vec![0, 1, 2, 3, 4, 5, 6, 7], None), Op::Call(87, vec![22], 10, false), Op::Call(87, vec![151], 10, false), Op::Call(87, vec![161], 10, false), Op::Call(87, vec![171], 10, false), Op::Call(87, vec![181], 10, false), Op::Call(87, vec![191], 10, false), Op::Call(87, vec![201], 10, false), Op::Store(vec![19, 19, 19, 19, 19, 19, 19, 19, 19, 19]), Op::Store(vec![16, 203, 204, 205, 206, 207, 208, 209, 210, 212]), Op::Store(vec![16, 193, 194, 195, 196, 197, 198, 199, 200, 213]), Op::Store(vec![16, 183, 184, 185, 186, 187, 188, 189, 190, 214]), Op::Store(vec![16, 173, 174, 175, 176, 177, 178, 179, 180, 215]), Op::Store(vec![16, 163, 164, 165, 166, 167, 168, 169, 170, 216]), Op::Store(vec![16, 153, 154, 155, 156, 157, 158, 159, 160, 217]), Op::Store(vec![16, 143, 144, 145, 146, 147, 148, 149, 150, 218]), Op::Call(87, vec![211], 10, false), Op::Call(100, vec![229, 220], 3, false), Op::Call(101, vec![232], 3, false), Op::Call(102, vec![235, 220], 2, false), Op::Store(vec![16, 221, 222, 223, 224, 225, 226, 227, 228, 231]), Op::Call(251, vec![219, 238], 1, false), Op::Load(3, 237), Op::AssertEq(vec![240, 241, 242], vec![19, 19, 19], None), Op::Const(G::from_u64(2)), Op::IOGetInfo(243, vec![16]), Op::Call(1, vec![243, 244, 245], 1, true), Op::Call(75, vec![246, 54, 16, 16, 55, 56, 57], 1, false), Op::Call(74, vec![247], 32, false), Op::Mul(91, 249), Op::Mul(93, 250), Op::Mul(95, 251), Op::Add(281, 282), Op::Add(280, 283), Op::Add(248, 284), Op::Mul(91, 253), Op::Mul(93, 254), Op::Mul(95, 255), Op::Add(287, 288), Op::Add(286, 289), Op::Add(252, 290), Op::Mul(91, 257), Op::Mul(93, 258), Op::Mul(95, 259), Op::Add(293, 294), Op::Add(292, 295), Op::Add(256, 296), Op::Mul(91, 261), Op::Mul(93, 262), Op::Mul(95, 263), Op::Add(299, 300), Op::Add(298, 301), Op::Add(260, 302), Op::Mul(91, 265), Op::Mul(93, 266), Op::Mul(95, 267), Op::Add(305, 306), Op::Add(304, 307), Op::Add(264, 308), Op::Mul(91, 269), Op::Mul(93, 270), Op::Mul(95, 271), Op::Add(311, 312), Op::Add(310, 313), Op::Add(268, 314), Op::Mul(91, 273), Op::Mul(93, 274), Op::Mul(95, 275), Op::Add(317, 318), Op::Add(316, 319), Op::Add(272, 320), Op::Mul(91, 277), Op::Mul(93, 278), Op::Mul(95, 279), Op::Add(323, 324), Op::Add(322, 325), Op::Add(276, 326), Op::AssertEq(vec![285, 291, 297, 303, 309, 315, 321, 327], vec![8, 9, 10, 11, 12, 13, 14, 15], None), Op::Call(26, vec![246], 2, false), Op::Call(235, vec![329, 328], 2, false), Op::Load(3, 331), Op::AssertEq(vec![332, 333, 334], vec![19, 19, 19], None), Op::Call(29, vec![17], 2, false), Op::Call(63, vec![336, 335], 2, false), Op::Call(29, vec![338], 2, false), Op::Call(66, vec![340, 339], 2, false), Op::Call(29, vec![342], 2, false), Op::Call(68, vec![344, 343], 2, false), Op::Add(17, 18), Op::AssertEq(vec![346], vec![347], None), Op::Call(232, vec![142, 152, 162, 172, 182, 192, 202, 239, 230, 233, 234, 236, 337, 341, 345], 1, false), Op::Call(217, vec![348, 330], 1, false), Op::AssertEq(vec![349], vec![19], None), Op::AssertEq(vec![19], vec![19], None)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 201, lookups: 42 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_239() -> Function { + Function { body: Block { ops: vec![Op::Call(253, vec![0, 1], 1, false), Op::Load(3, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_240() -> Function { + Function { body: Block { ops: vec![Op::Load(26, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(0), Block { ops: vec![Op::Call(240, vec![26], 1, false), Op::Const(G::from_u64(1)), Op::Add(27, 28)], ctrl: Ctrl::Return(1, vec![29]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_241() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(241, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 5)], ctrl: Ctrl::Return(1, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_242() -> Function { + Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(242, vec![4], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 6)], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_243() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(243, vec![4, 1], 1, false), Op::Store(vec![5, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_244() -> Function { + Function { body: Block { ops: vec![Op::Load(6, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(244, vec![6], 1, false), Op::Const(G::from_u64(1)), Op::Add(7, 8)], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_245() -> Function { + Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(245, vec![7], 1, false), Op::Const(G::from_u64(1)), Op::Add(8, 9)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_246() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(0), Block { ops: vec![Op::Call(246, vec![10], 1, false), Op::Const(G::from_u64(1)), Op::Add(11, 12)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_247() -> Function { + Function { body: Block { ops: vec![Op::Load(11, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::Add(12, 13)], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 13, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_248() -> Function { + Function { body: Block { ops: vec![Op::Call(255, vec![0, 1], 1, false), Op::Load(6, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_249() -> Function { + Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_250() -> Function { + Function { body: Block { ops: vec![Op::Call(254, vec![0, 1], 1, false), Op::Load(4, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_251() -> Function { + Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(251, vec![11, 1], 1, false), Op::Store(vec![12, 3, 4, 5, 6, 7, 8, 9, 10, 13])], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 13, lookups: 4 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_252() -> Function { + Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(0), Block { ops: vec![Op::Call(252, vec![5], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 7)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_253() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(253, vec![0, 3], 1, false), Op::Load(3, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_254() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(254, vec![0, 3], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } +} + +#[inline(never)] +fn expected_function_255() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 2), Op::Call(255, vec![0, 3], 1, false), Op::Load(6, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 3 }, entry: false, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21(), expected_function_22(), expected_function_23(), expected_function_24(), expected_function_25(), expected_function_26(), expected_function_27(), expected_function_28(), expected_function_29(), expected_function_30(), expected_function_31(), expected_function_32(), expected_function_33(), expected_function_34(), expected_function_35(), expected_function_36(), expected_function_37(), expected_function_38(), expected_function_39(), expected_function_40(), expected_function_41(), expected_function_42(), expected_function_43(), expected_function_44(), expected_function_45(), expected_function_46(), expected_function_47(), expected_function_48(), expected_function_49(), expected_function_50(), expected_function_51(), expected_function_52(), expected_function_53(), expected_function_54(), expected_function_55(), expected_function_56(), expected_function_57(), expected_function_58(), expected_function_59(), expected_function_60(), expected_function_61(), expected_function_62(), expected_function_63(), expected_function_64(), expected_function_65(), expected_function_66(), expected_function_67(), expected_function_68(), expected_function_69(), expected_function_70(), expected_function_71(), expected_function_72(), expected_function_73(), expected_function_74(), expected_function_75(), expected_function_76(), expected_function_77(), expected_function_78(), expected_function_79(), expected_function_80(), expected_function_81(), expected_function_82(), expected_function_83(), expected_function_84(), expected_function_85(), expected_function_86(), expected_function_87(), expected_function_88(), expected_function_89(), expected_function_90(), expected_function_91(), expected_function_92(), expected_function_93(), expected_function_94(), expected_function_95(), expected_function_96(), expected_function_97(), expected_function_98(), expected_function_99(), expected_function_100(), expected_function_101(), expected_function_102(), expected_function_103(), expected_function_104(), expected_function_105(), expected_function_106(), expected_function_107(), expected_function_108(), expected_function_109(), expected_function_110(), expected_function_111(), expected_function_112(), expected_function_113(), expected_function_114(), expected_function_115(), expected_function_116(), expected_function_117(), expected_function_118(), expected_function_119(), expected_function_120(), expected_function_121(), expected_function_122(), expected_function_123(), expected_function_124(), expected_function_125(), expected_function_126(), expected_function_127(), expected_function_128(), expected_function_129(), expected_function_130(), expected_function_131(), expected_function_132(), expected_function_133(), expected_function_134(), expected_function_135(), expected_function_136(), expected_function_137(), expected_function_138(), expected_function_139(), expected_function_140(), expected_function_141(), expected_function_142(), expected_function_143(), expected_function_144(), expected_function_145(), expected_function_146(), expected_function_147(), expected_function_148(), expected_function_149(), expected_function_150(), expected_function_151(), expected_function_152(), expected_function_153(), expected_function_154(), expected_function_155(), expected_function_156(), expected_function_157(), expected_function_158(), expected_function_159(), expected_function_160(), expected_function_161(), expected_function_162(), expected_function_163(), expected_function_164(), expected_function_165(), expected_function_166(), expected_function_167(), expected_function_168(), expected_function_169(), expected_function_170(), expected_function_171(), expected_function_172(), expected_function_173(), expected_function_174(), expected_function_175(), expected_function_176(), expected_function_177(), expected_function_178(), expected_function_179(), expected_function_180(), expected_function_181(), expected_function_182(), expected_function_183(), expected_function_184(), expected_function_185(), expected_function_186(), expected_function_187(), expected_function_188(), expected_function_189(), expected_function_190(), expected_function_191(), expected_function_192(), expected_function_193(), expected_function_194(), expected_function_195(), expected_function_196(), expected_function_197(), expected_function_198(), expected_function_199(), expected_function_200(), expected_function_201(), expected_function_202(), expected_function_203(), expected_function_204(), expected_function_205(), expected_function_206(), expected_function_207(), expected_function_208(), expected_function_209(), expected_function_210(), expected_function_211(), expected_function_212(), expected_function_213(), expected_function_214(), expected_function_215(), expected_function_216(), expected_function_217(), expected_function_218(), expected_function_219(), expected_function_220(), expected_function_221(), expected_function_222(), expected_function_223(), expected_function_224(), expected_function_225(), expected_function_226(), expected_function_227(), expected_function_228(), expected_function_229(), expected_function_230(), expected_function_231(), expected_function_232(), expected_function_233(), expected_function_234(), expected_function_235(), expected_function_236(), expected_function_237(), expected_function_238(), expected_function_239(), expected_function_240(), expected_function_241(), expected_function_242(), expected_function_243(), expected_function_244(), expected_function_245(), expected_function_246(), expected_function_247(), expected_function_248(), expected_function_249(), expected_function_250(), expected_function_251(), expected_function_252(), expected_function_253(), expected_function_254(), expected_function_255()], memory_sizes: vec![3, 4, 5, 6, 7, 8, 10, 11, 26, 32, 34], circuits: vec![Circuit { members: vec![0, 2, 11, 12, 96, 119, 120, 121, 122, 164, 180, 188], layout: FunctionLayout { input_size: 8, selectors: 40, auxiliaries: 20, lookups: 7 } }, Circuit { members: vec![10], layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![24, 38, 88, 90, 97, 141, 182, 189, 203, 204, 205, 247], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 18, lookups: 6 } }, Circuit { members: vec![25, 73, 74, 89, 125, 136, 148, 157, 165, 173, 174, 177, 194], layout: FunctionLayout { input_size: 44, selectors: 26, auxiliaries: 137, lookups: 14 } }, Circuit { members: vec![26, 46, 54, 57, 59, 108, 137, 155, 170, 176, 201, 237, 245, 251], layout: FunctionLayout { input_size: 9, selectors: 26, auxiliaries: 98, lookups: 32 } }, Circuit { members: vec![29, 255], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 3 } }, Circuit { members: vec![33, 43, 47, 105, 124, 138, 149, 151, 159, 160, 163, 175], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![34, 241], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![35], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![36, 44, 45, 77, 87, 110, 118, 127, 132, 133, 171], layout: FunctionLayout { input_size: 2, selectors: 21, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![37, 192], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 23, lookups: 3 } }, Circuit { members: vec![39, 50, 102, 116, 128, 135, 139, 154, 158, 161, 178, 183, 185, 197, 252], layout: FunctionLayout { input_size: 8, selectors: 31, auxiliaries: 42, lookups: 9 } }, Circuit { members: vec![41, 94], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![60], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 21 } }, Circuit { members: vec![63], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 10 } }, Circuit { members: vec![66], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 16, lookups: 4 } }, Circuit { members: vec![68], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 30, lookups: 4 } }, Circuit { members: vec![75], layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![76, 78, 79, 100, 172, 200], layout: FunctionLayout { input_size: 20, selectors: 25, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![83], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![84], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![85], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![86], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![92, 101, 142, 150, 156, 162, 198, 202, 235, 244], layout: FunctionLayout { input_size: 25, selectors: 37, auxiliaries: 46, lookups: 20 } }, Circuit { members: vec![93], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 } }, Circuit { members: vec![109, 187], layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![111], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 } }, Circuit { members: vec![112, 123, 131], layout: FunctionLayout { input_size: 4, selectors: 10, auxiliaries: 34, lookups: 13 } }, Circuit { members: vec![113], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 } }, Circuit { members: vec![114], layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 } }, Circuit { members: vec![117, 126, 250, 254], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![130], layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 } }, Circuit { members: vec![140], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 4 } }, Circuit { members: vec![143], layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 19, lookups: 9 } }, Circuit { members: vec![144, 145, 146, 147, 191, 193], layout: FunctionLayout { input_size: 19, selectors: 12, auxiliaries: 14, lookups: 7 } }, Circuit { members: vec![168], layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![190], layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 } }, Circuit { members: vec![206], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![207], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![208], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![209], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 } }, Circuit { members: vec![210], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![211], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![212], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 } }, Circuit { members: vec![213], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 } }, Circuit { members: vec![214], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 } }, Circuit { members: vec![215], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![216], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 } }, Circuit { members: vec![217], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![218], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 } }, Circuit { members: vec![219], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 } }, Circuit { members: vec![220], layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 } }, Circuit { members: vec![221], layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 } }, Circuit { members: vec![222], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![223], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![224], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 } }, Circuit { members: vec![225], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 } }, Circuit { members: vec![226], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![227], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![228], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 } }, Circuit { members: vec![229], layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 } }, Circuit { members: vec![230], layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 } }, Circuit { members: vec![231], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![232], layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 } }, Circuit { members: vec![238], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 201, lookups: 42 } }, Circuit { members: vec![239, 242, 253], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![240], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 } }, Circuit { members: vec![243], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![246], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![248], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![249], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [190, 78, 33, 75, 247, 82, 112, 163, 173, 204, 83, 141, 6, 196, 161, 203, 161, 99, 163, 87, 1, 40, 26, 136, 174, 21, 15, 159, 197, 168, 147, 208], complete: false, expected: expected_program, functions: &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, output_size: 64, seed_words: 194, schema: &SCHEMA_76, pack: pack_76, pack_typed: pack_76_typed, write: write_76 }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, output_size: 1, seed_words: 146, schema: &SCHEMA_78, pack: pack_78, pack_typed: pack_78_typed, write: |seed, offsets, row| { write_78(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, output_size: 1, seed_words: 158, schema: &SCHEMA_79, pack: pack_79, pack_typed: pack_79_typed, write: |seed, offsets, row| { write_79(seed, offsets, row); Ok(()) } }), +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_83, pack: pack_83, pack_typed: pack_83_typed, write: |seed, offsets, row| { write_83(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, output_size: 3, seed_words: 69, schema: &SCHEMA_100, pack: pack_100, pack_typed: pack_100_typed, write: |seed, offsets, row| { write_100(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 }, output_size: 1, seed_words: 201, schema: &SCHEMA_114, pack: pack_114, pack_typed: pack_114_typed, write: |seed, offsets, row| { write_114(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, output_size: 10, seed_words: 76, schema: &SCHEMA_172, pack: pack_172, pack_typed: pack_172_typed, write: write_172 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 20, selectors: 7, auxiliaries: 152, lookups: 50 }, output_size: 1, seed_words: 94, schema: &SCHEMA_200, pack: pack_200, pack_typed: pack_200_typed, write: write_200 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_217, pack: pack_217, pack_typed: pack_217_typed, write: write_217 }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 1, seed_words: 25, schema: &SCHEMA_227, pack: pack_227, pack_typed: pack_227_typed, write: |seed, offsets, row| { write_227(seed, offsets, row); Ok(()) } }), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +] }; diff --git a/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs b/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs new file mode 100644 index 000000000..074271e6f --- /dev/null +++ b/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs @@ -0,0 +1,274 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_multi_stark_contract() -> *const u8; + fn aiur_trace_multi_stark_schema() -> *const u8; + pub(super) fn aiur_trace_multi_stark_76(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_78(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_79(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_83(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_100(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_114(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_172(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_200(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_217(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_multi_stark_227(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([190, 78, 33, 75, 247, 82, 112, 163, 173, 204, 83, 141, 6, 196, 161, 203, 161, 99, 163, 87, 1, 40, 26, 136, 174, 21, 15, 159, 197, 168, 147, 208], aiur_trace_multi_stark_contract, aiur_trace_multi_stark_schema, &[ +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_76), +None, +Some(aiur_trace_multi_stark_78), +Some(aiur_trace_multi_stark_79), +None, +None, +None, +Some(aiur_trace_multi_stark_83), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_100), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_114), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_172), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_200), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_217), +None, +None, +None, +None, +None, +None, +None, +None, +None, +Some(aiur_trace_multi_stark_227), +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None, +None +], &[3, 0, 9, 0, 0, 0, 0, 0, 0, 0, 17, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 18, 12, 0, 0, 12, 0, 0, 0, 8, 6, 15, 6, 24, 6, 43, 0, 8, 0, 10, 6, 8, 6, 8, 0, 0, 8, 0, 0, 0, 12, 0, 0, 14, 0, 6, 52, 0, 0, 20, 0, 0, 17, 0, 31, 0, 0, 0, 0, 170, 137, 13, 194, 5, 146, 158, 0, 0, 0, 162, 5, 4, 6, 6, 10, 18, 11, 0, 43, 15, 8, 0, 12, 5, 0, 0, 69, 8, 8, 0, 0, 10, 0, 0, 100, 5, 7, 22, 22, 27, 201, 0, 43, 8, 6, 18, 18, 19, 15, 33, 9, 22, 8, 7, 13, 0, 27, 10, 8, 8, 0, 8, 17, 42, 8, 8, 21, 11, 3, 19, 17, 19, 20, 23, 22, 8, 6, 11, 0, 0, 16, 41, 54, 36, 10, 10, 11, 9, 30, 9, 11, 23, 0, 0, 18, 0, 43, 8, 76, 23, 23, 8, 20, 13, 6, 0, 15, 0, 6, 3, 0, 3, 0, 7, 5, 14, 24, 29, 9, 33, 81, 0, 0, 12, 2, 0, 94, 16, 15, 6, 19, 12, 4, 6, 10, 12, 11, 6, 19, 68, 48, 10, 25, 11, 78, 12, 23, 2, 7, 6, 2, 42, 4, 25, 78, 119, 59, 10, 32, 0, 0, 10, 0, 15, 217, 7, 29, 6, 7, 8, 9, 10, 13, 14, 10, 5, 8, 15, 8, 7, 8, 10], &[16, 0, 72, 0, 0, 0, 0, 0, 0, 0, 136, 72, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 112, 88, 0, 0, 96, 0, 0, 0, 56, 48, 112, 48, 184, 48, 336, 0, 56, 0, 72, 48, 56, 48, 56, 0, 0, 56, 0, 0, 0, 80, 0, 0, 96, 0, 48, 352, 0, 0, 136, 0, 0, 128, 0, 176, 0, 0, 0, 0, 432, 840, 80, 848, 40, 416, 272, 0, 0, 0, 176, 32, 32, 40, 40, 64, 112, 88, 0, 312, 96, 48, 0, 72, 40, 0, 0, 304, 48, 48, 0, 0, 64, 0, 0, 120, 32, 40, 136, 128, 128, 544, 0, 312, 40, 40, 96, 112, 120, 72, 176, 56, 120, 48, 48, 96, 0, 192, 64, 48, 48, 0, 48, 120, 280, 64, 56, 144, 72, 24, 128, 112, 144, 144, 168, 160, 56, 32, 80, 0, 0, 120, 224, 336, 216, 56, 64, 64, 48, 160, 56, 64, 112, 0, 0, 112, 0, 312, 48, 464, 168, 168, 48, 104, 96, 40, 0, 104, 0, 48, 24, 0, 24, 0, 56, 40, 88, 192, 224, 72, 256, 632, 0, 0, 88, 16, 0, 616, 120, 104, 32, 120, 64, 32, 40, 64, 72, 64, 40, 128, 432, 344, 48, 160, 40, 552, 72, 168, 16, 32, 40, 16, 232, 24, 88, 576, 688, 320, 64, 184, 0, 0, 56, 0, 104, 1144, 48, 152, 40, 48, 48, 64, 72, 96, 96, 72, 32, 56, 104, 48, 48, 56, 72]) }; diff --git a/crates/aiur/src/trace_codegen/tests.rs b/crates/aiur/src/trace_codegen/tests.rs new file mode 100644 index 000000000..ee8cadbe9 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests.rs @@ -0,0 +1,523 @@ +use super::*; +use crate::execute::IOKeyInfo; + +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod generated; + +#[cfg(feature = "cuda-trace-codegen")] +#[allow(unreachable_pub)] +#[rustfmt::skip] +mod generated_cuda; + +#[cfg(feature = "cuda-trace-codegen")] +mod cuda; +#[cfg(feature = "cuda-trace-codegen")] +#[allow(unreachable_pub)] +#[rustfmt::skip] +pub(crate) mod blake3; +#[cfg(feature = "cuda-trace-codegen")] +#[allow(unreachable_pub)] +#[rustfmt::skip] +pub(crate) mod blake3_cuda; + +fn io() -> IOBuffer { + IOBuffer { data: Default::default(), map: Default::default() } +} + +fn circuit_of(program: &Toplevel, function: usize) -> usize { + program.circuits.iter().position(|c| c.members.contains(&function)).unwrap() +} + +fn snapshot(record: &QueryRecord) -> Vec { + let mut words = vec![]; + for table in + record.function_queries.iter().chain(record.memory_queries.values()) + { + words.push(u64::try_from(table.len()).unwrap()); + for (key, result) in table.iter() { + words + .extend(key.iter().chain(result.output).map(|x| x.as_canonical_u64())); + words.push(result.multiplicity.as_canonical_u64()); + } + } + words +} + +fn parity(program: &Toplevel, record: &QueryRecord, io: &IOBuffer) -> usize { + let bound = generated::PROGRAM.bind(program).unwrap(); + let before = snapshot(record); + let mut checked = 0; + for (index, queries) in record.function_queries.iter().enumerate() { + let Some(writer) = bound.function(index) else { + continue; + }; + let circuit = circuit_of(program, index); + for query in 0..queries.len() { + if queries.get_index(query).unwrap().1.multiplicity == G::ZERO { + continue; + } + let mut seed = vec![u64::MAX; writer.seed_words()]; + writer.pack_row(record, io, query, &mut seed).unwrap(); + let schema = writer.schema(); + assert!(schema.is_consistent()); + let mut direct = vec![0xff; schema.bytes]; + let fits = writer.pack_typed_row(record, io, query, &mut direct).unwrap(); + assert_eq!( + fits, + seed.iter().zip(schema.widths).all(|(&word, width)| width.fits(word)), + "function {index}, query {query}: typed guard" + ); + let encoding = + if fits { SeedEncoding::Typed } else { SeedEncoding::Canonical }; + let mut packed = vec![0xff; encoding.stride(schema)]; + encoding.encode(schema, &seed, &mut packed).unwrap(); + if fits { + assert_eq!(direct, packed, "direct typed seed differs"); + } else { + assert!( + SeedEncoding::Typed.encode(schema, &seed, &mut direct).is_err() + ); + } + let mut decoded = vec![0; seed.len()]; + encoding.decode(schema, &packed, &mut decoded).unwrap(); + assert_eq!(seed, decoded); + let expected = + program.main_row_for_test(circuit, index, query, record, io); + let mut actual = vec![u64::MAX; expected.len()]; + writer.write_row(&decoded, circuit, &mut actual).unwrap(); + for (column, (actual, expected)) in + actual.iter().zip(&expected).enumerate() + { + assert_eq!( + *actual, + expected.as_canonical_u64(), + "function {index}, query {query}, column {column}" + ); + assert!(*actual < G::ORDER_U64); + } + checked += 1; + } + } + #[cfg(feature = "cuda-trace-codegen")] + cuda::parity(program, record, io); + assert_eq!(before, snapshot(record), "packing changed the finalized record"); + checked +} + +fn run(function: usize, args: &[u64]) -> usize { + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let (record, _) = program + .execute(function, args.iter().copied().map(G::from_u64).collect(), &mut io) + .unwrap(); + parity(&program, &record, &io) +} + +#[test] +fn canonical_fields_zero_inverses_and_constant_degree() { + let boundary = [0, 1, 2, 255, 256, (1 << 32) - 1, 1 << 32, G::ORDER_U64 - 1]; + for a in boundary { + for b in boundary { + assert_eq!(run(0, &[a, b]), 1); + } + } + assert_eq!(run(12, &[]), 1); +} + +#[test] +fn byte_operations_and_virtual_carries() { + let boundary = [0, 1, 15, 16, 127, 128, 254, 255]; + for a in boundary { + for b in boundary { + assert_eq!(run(1, &[a, b]), 1); + } + } +} + +#[test] +fn u32_boundaries_and_virtual_values() { + let boundary = [0_u32, 1, 255, 256, 1 << 31, u32::MAX]; + for a in boundary { + for b in boundary { + let args: Vec<_> = [a, b, u32::MAX] + .iter() + .flat_map(|word| word.to_le_bytes().map(u64::from)) + .collect(); + assert_eq!(run(2, &args), 1); + } + } +} + +#[test] +fn branch_columns_and_grouped_member_offsets() { + for tag in [0, 1, 2, G::ORDER_U64 - 1] { + for value in [0, 1, 127, 255] { + assert_eq!(run(3, &[tag, value]), 1); + } + } + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for (function, args) in [ + (0, vec![G::ZERO, -G::ONE]), + (3, vec![G::ONE, G::from_u8(255)]), + (12, vec![]), + ] { + program.execute_in(function, args, &mut io, &mut record).unwrap(); + } + assert_eq!(parity(&program, &record, &io), 3); +} + +#[test] +fn call_load_dependencies_and_nonzero_pointer_namespace() { + let program = (generated::PROGRAM.expected)(); + for base in [0, 1024, 1 << 30] { + let mut io = io(); + let (record, _) = program + .execute_with_pointer_base(4, vec![G::from_u8(7)], &mut io, base) + .unwrap(); + assert_eq!(parity(&program, &record, &io), 2); + } +} + +#[test] +fn early_returns_do_not_resolve_unexecuted_reads() { + for function in [8, 9] { + assert_eq!(run(function, &[0]), 1); + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::with_pointer_base(&program, 7); + record + .memory_queries + .get_mut(&1) + .unwrap() + .insert(&[G::from_u8(42)], &[G::from_u8(7)], G::ZERO) + .unwrap(); + let mut io = io(); + program + .execute_in(function, vec![G::from_u8(7)], &mut io, &mut record) + .unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + record.memory_queries.clear(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(function).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + let error = writer.pack_row(&record, &io, 0, &mut seed).unwrap_err(); + assert!(error.detail.contains("missing loaded values")); + } +} + +#[test] +fn io_reads_and_shared_branch_seed_slots() { + let program = (generated::PROGRAM.expected)(); + let channel = G::from_u8(3); + let mut io = io(); + io.data.insert(channel, vec![G::ONE, G::TWO, G::from_u8(77)]); + io.map.insert((channel, vec![G::from_u8(12)]), IOKeyInfo { idx: 0, len: 2 }); + let (record, _) = + program.execute(7, vec![channel, G::from_u8(12)], &mut io).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + for tag in [0, 1] { + let (record, _) = + program.execute(10, vec![G::from_u64(tag), channel], &mut io).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + } +} + +fn store_list(record: &mut QueryRecord, limbs: &[u64]) -> G { + let table = record.memory_queries.get_mut(&10).unwrap(); + let mut nil = [G::ZERO; 10]; + nil[0] = G::ONE; + if table.is_empty() { + table.insert(&nil, &[G::from_usize(record.pointer_base)], G::ZERO).unwrap(); + } + let mut pointer = G::from_usize(record.pointer_base); + for limb in limbs.iter().rev() { + let mut node = [G::ZERO; 10]; + node[1..9].copy_from_slice(&limb.to_le_bytes().map(G::from_u8)); + node[9] = pointer; + pointer = if let Some(query) = table.get(&node) { + query.output[0] + } else { + let pointer = G::from_usize(record.pointer_base + table.len()); + table.insert(&node, &[pointer], G::ZERO).unwrap(); + pointer + }; + } + pointer +} + +#[test] +fn big_uint_results_resolve_existing_list_nodes() { + let program = (generated::PROGRAM.expected)(); + for base in [0, 4096] { + for divisor in [vec![], vec![7], vec![3, 2]] { + let mut record = QueryRecord::with_pointer_base(&program, base); + let a = store_list(&mut record, &[u64::MAX, 9]); + let b = store_list(&mut record, &divisor); + let mut io = io(); + program.execute_in(11, vec![a, b], &mut io, &mut record).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + } + } +} + +#[test] +fn zero_output_reads_do_not_need_seeds() { + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + record + .memory_queries + .get_mut(&0) + .unwrap() + .insert(&[], &[G::ZERO], G::ZERO) + .unwrap(); + let mut io = io(); + program.execute_in(15, vec![G::ZERO], &mut io, &mut record).unwrap(); + assert_eq!(parity(&program, &record, &io), 2); +} + +#[test] +fn current_blake3_bytecode_all_stages_and_negative_multiplicities() { + let program = (generated::PROGRAM.expected)(); + assert_eq!(program.functions[17].layout.width(), 533); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(17).unwrap(); + assert_eq!(writer.seed_words(), 162); + // Multiplicity and the stage word stay full width; the 128 message bytes + // and 32 aliased output bytes narrow, so the typed seed matches the + // handwritten provider's 176 bytes without a function-name special case. + assert_eq!(writer.schema().bytes, 176); + assert_eq!(writer.schema().widths[1], SeedWidth::Full); + assert!(writer.schema().widths[2..].iter().all(|&w| w == SeedWidth::U8)); + for sample in 0..4 { + let mut state = 0x12345678_u64 + sample; + let mut args = vec![G::ZERO]; + for _ in 0..128 { + state = state.wrapping_mul(6364136223846793005).wrapping_add(1); + args.push(G::from_u8((state >> 56) as u8)); + } + let mut io = io(); + let (mut record, _) = program.execute(17, args, &mut io).unwrap(); + assert_eq!(record.function_queries[17].len(), 8); + for i in 0..8 { + *record.function_queries[17].get_index_mut(i).unwrap().1 = + if i % 2 == 0 { -G::ONE } else { G::from_u64(1 << 40) }; + } + assert_eq!(parity(&program, &record, &io), 8); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io, 7, &mut seed).unwrap(); + drop(record); + let mut row = vec![0; 533]; + writer.write_row(&seed, circuit_of(&program, 17), &mut row).unwrap(); + } +} + +#[test] +fn partial_coverage_keeps_library_and_descriptor_checks() { + let program = (generated::PROGRAM.expected)(); + let mut functions = generated::PROGRAM.functions.to_vec(); + functions[0] = None; + let mut partial = GeneratedProgram { + fingerprint: generated::PROGRAM.fingerprint, + complete: true, + expected: generated::PROGRAM.expected, + functions: Box::leak(functions.into_boxed_slice()), + }; + assert!(partial.bind(&program).is_err()); + partial.complete = false; + let bound = partial.bind(&program).unwrap(); + assert!(bound.function(0).is_none()); + assert!(bound.function(1).is_some()); + let mut changed = (generated::PROGRAM.expected)(); + changed.functions[0].body.ops.push(crate::bytecode::Op::Const(G::ONE)); + assert!(partial.bind(&changed).is_err()); + let mut functions = partial.functions.to_vec(); + functions[13] = functions[1]; + partial.functions = Box::leak(functions.into_boxed_slice()); + assert!(partial.bind(&program).is_err()); +} + +#[test] +fn library_binding_rejects_changed_callees_and_grouping() { + let mut program = (generated::PROGRAM.expected)(); + program.functions[13].body.ops.push(crate::bytecode::Op::Const(G::ONE)); + assert!(generated::PROGRAM.bind(&program).is_err()); + let mut program = (generated::PROGRAM.expected)(); + program.circuits[0].members.swap(0, 1); + assert!(generated::PROGRAM.bind(&program).is_ok()); + program.circuits[0].members.push(0); + assert!(generated::PROGRAM.bind(&program).is_err()); + let mut program = (generated::PROGRAM.expected)(); + let Ctrl::MatchContinue(_, arms, ..) = &mut program.functions[3].body.ctrl + else { + unreachable!() + }; + arms.swap_indices(0, 1); + assert!(generated::PROGRAM.bind(&program).is_err()); +} + +#[test] +fn seed_codec_guards_and_wide_fallback() { + use SeedWidth::*; + // Wider words first, in index order, so every word is naturally aligned. + static MIXED: SeedSchema = SeedSchema { + widths: &[Full, U8, U32, U16, Full, U8], + offsets: &[0, 22, 16, 20, 8, 23], + bytes: 24, + }; + assert!(MIXED.is_consistent()); + assert!(!MIXED.is_canonical()); + static SKEWED: SeedSchema = + SeedSchema { widths: &[Full, U8], offsets: &[0, 9], bytes: 16 }; + assert!(!SKEWED.is_consistent()); + static PAYLOAD_FIRST: SeedSchema = + SeedSchema { widths: &[U8, Full], offsets: &[0, 8], bytes: 16 }; + assert!(!PAYLOAD_FIRST.is_consistent()); + + let words = [G::ORDER_U64 - 1, 255, u64::from(u32::MAX), 65535, 1 << 40, 0]; + for encoding in [SeedEncoding::Typed, SeedEncoding::Canonical] { + let mut bytes = vec![0xff; encoding.stride(&MIXED)]; + encoding.encode(&MIXED, &words, &mut bytes).unwrap(); + let mut decoded = vec![0; words.len()]; + encoding.decode(&MIXED, &bytes, &mut decoded).unwrap(); + assert_eq!(words, decoded[..]); + } + let mut typed = vec![0; 24]; + SeedEncoding::Typed.encode(&MIXED, &words, &mut typed).unwrap(); + assert_eq!(&typed[..8], &(G::ORDER_U64 - 1).to_le_bytes()); + assert_eq!(&typed[8..16], &(1u64 << 40).to_le_bytes()); + assert_eq!(&typed[16..20], &u32::MAX.to_le_bytes()); + assert_eq!(&typed[20..22], &u16::MAX.to_le_bytes()); + assert_eq!(&typed[22..], &[255, 0]); + + // Each narrowed word guards its own bound; the wide fallback takes anything. + for (index, wide) in [(1, 256), (2, 1 << 32), (3, 65536), (5, 1)] { + let mut words = words; + words[index] = wide; + assert_eq!( + SeedEncoding::Typed.encode(&MIXED, &words, &mut typed).is_err(), + index != 5 + ); + let mut canonical = vec![0; 48]; + SeedEncoding::Canonical.encode(&MIXED, &words, &mut canonical).unwrap(); + } + assert!( + SeedEncoding::Typed + .encode(&MIXED, &[G::ORDER_U64, 0, 0, 0, 0, 0], &mut typed) + .is_err() + ); + assert!(SeedEncoding::Typed.encode(&MIXED, &words[..5], &mut typed).is_err()); + assert!( + SeedEncoding::Canonical.decode(&MIXED, &[0; 48], &mut [0; 5]).is_err() + ); + let mut noncanonical = [0; 48]; + noncanonical[..8].copy_from_slice(&G::ORDER_U64.to_le_bytes()); + assert!( + SeedEncoding::Canonical.decode(&MIXED, &noncanonical, &mut [0; 6]).is_err() + ); + static PADDED: SeedSchema = + SeedSchema { widths: &[Full, U8], offsets: &[0, 8], bytes: 16 }; + let mut padded = [0; 16]; + padded[15] = 1; + assert!(SeedEncoding::Typed.decode(&PADDED, &padded, &mut [0; 2]).is_err()); + padded[15] = 0; + padded[8] = 9; + let mut decoded = [0; 2]; + SeedEncoding::Typed.decode(&PADDED, &padded, &mut decoded).unwrap(); + assert_eq!(decoded, [0, 9]); +} + +#[test] +fn typed_guard_failure_leaves_the_span_full_width() { + // Function 3 narrows its value input to a byte because one arm adds it as + // a byte, but the multiply arm accepts any field element. Rows taking that + // arm with a wide value must fail the guard and pack full width. + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let (record, _) = + program.execute(3, vec![G::ZERO, G::from_u64(1 << 32)], &mut io).unwrap(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(3).unwrap(); + assert_eq!(writer.schema().widths[2], SeedWidth::U8); + let mut typed = vec![0; writer.schema().bytes]; + assert!(!writer.pack_typed_row(&record, &io, 0, &mut typed).unwrap()); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io, 0, &mut seed).unwrap(); + assert_eq!(seed[2], 1 << 32); + assert_eq!(parity(&program, &record, &io), 1); +} + +#[test] +fn scalar_rejects_noncanonical_seed_words() { + let program = (generated::PROGRAM.expected)(); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(0).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + seed[0] = G::ORDER_U64; + let mut row = vec![0; program.circuits[0].layout.width()]; + assert!(writer.write_row(&seed, 0, &mut row).is_err()); +} + +#[test] +fn nested_yields_compute_host_read_keys() { + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let channel = G::from_u8(3); + io.data.insert(channel, vec![G::ZERO, G::ONE, G::TWO, G::from_u8(3)]); + for outer in [0, 1] { + for inner in [0, 1, 2] { + let (record, _) = program + .execute( + 18, + vec![G::from_u8(outer), channel, G::from_u8(inner)], + &mut io, + ) + .unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + } + } +} + +#[test] +fn missing_match_and_inactive_queries_are_rejected() { + let program = (generated::PROGRAM.expected)(); + let mut io = io(); + let (mut record, _) = program.execute(19, vec![G::ZERO], &mut io).unwrap(); + assert_eq!(parity(&program, &record, &io), 1); + let bound = generated::PROGRAM.bind(&program).unwrap(); + let writer = bound.function(19).unwrap(); + let mut seed = vec![0; writer.seed_words()]; + writer.pack_row(&record, &io, 0, &mut seed).unwrap(); + seed[1] = 7; + let circuit = circuit_of(&program, 19); + let mut row = vec![0; program.circuits[circuit].layout.width()]; + let error = writer.write_row(&seed, circuit, &mut row).unwrap_err(); + assert!(error.detail.contains("no match")); + *record.function_queries[19].get_index_mut(0).unwrap().1 = G::ZERO; + assert!(writer.pack_row(&record, &io, 0, &mut seed).is_err()); + seed[0] = 0; + assert!(writer.write_row(&seed, circuit, &mut row).is_err()); +} + +#[test] +fn canonical_wide_words_preserve_u128_carries() { + for value in [0, 255, 256, 1 << 32, G::ORDER_U64 - 1] { + assert_eq!(run(20, &[value; 12]), 1); + } +} + +#[test] +fn current_u64_multiply_bytecode_boundaries() { + for a in [0_u64, 1, 255, 65535, 1 << 32, u64::MAX] { + for b in [0_u64, 1, 65536, u64::MAX] { + let args: Vec<_> = a + .to_le_bytes() + .into_iter() + .chain(b.to_le_bytes()) + .map(u64::from) + .collect(); + assert_eq!(run(21, &args), 1); + } + } +} diff --git a/crates/aiur/src/trace_codegen/tests/blake3.rs b/crates/aiur/src/trace_codegen/tests/blake3.rs new file mode 100644 index 000000000..795a71080 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/blake3.rs @@ -0,0 +1,25 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_0(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_0_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn write_0(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_0: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(0, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: true, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0()], memory_sizes: vec![], circuits: vec![Circuit { members: vec![0], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [150, 101, 248, 224, 67, 209, 56, 216, 146, 162, 51, 114, 82, 15, 10, 181, 15, 234, 113, 117, 51, 141, 70, 70, 235, 90, 62, 221, 45, 109, 215, 133], complete: true, expected: expected_program, functions: &[ +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_0, pack: pack_0, pack_typed: pack_0_typed, write: |seed, offsets, row| { write_0(seed, offsets, row); Ok(()) } }) +] }; diff --git a/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs b/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs new file mode 100644 index 000000000..fd5b356ec --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs @@ -0,0 +1,10 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_blake3_contract() -> *const u8; + fn aiur_trace_blake3_schema() -> *const u8; + pub(super) fn aiur_trace_blake3_0(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([150, 101, 248, 224, 67, 209, 56, 216, 146, 162, 51, 114, 82, 15, 10, 181, 15, 234, 113, 117, 51, 141, 70, 70, 235, 90, 62, 221, 45, 109, 215, 133], aiur_trace_blake3_contract, aiur_trace_blake3_schema, &[ +Some(aiur_trace_blake3_0) +], &[162], &[176]) }; diff --git a/crates/aiur/src/trace_codegen/tests/cuda.rs b/crates/aiur/src/trace_codegen/tests/cuda.rs new file mode 100644 index 000000000..a898ce4f3 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/cuda.rs @@ -0,0 +1,714 @@ +use super::*; +use std::sync::Arc; + +use multi_stark::{ + p3_matrix::Matrix, + witness::{TraceGenerator, TraceSource}, +}; + +use crate::trace_codegen::cuda::{ + prepare_memory, prepare_memory_trace, seed_cache_bytes, +}; + +pub(super) fn parity(program: &Toplevel, record: &QueryRecord, io: &IOBuffer) { + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, program).unwrap(); + for (index, circuit) in program.circuits.iter().enumerate() { + let mut expected = Vec::new(); + for &member in &circuit.members { + for query in 0..record.function_queries[member].len() { + if record.function_queries[member] + .get_index(query) + .unwrap() + .1 + .multiplicity + == G::ZERO + { + continue; + } + expected.extend( + program + .main_row_for_test(index, member, query, record, io) + .into_iter() + .map(|g| g.as_canonical_u64()), + ); + } + } + if expected.is_empty() { + continue; + } + let rows = expected.len() / circuit.layout.width(); + let last = circuit.members.len() - 1; + let end = (last, record.function_queries[circuit.members[last]].len()); + let height = rows.next_power_of_two(); + let width = circuit.layout.width(); + expected.resize(height * width, 0); + // The typed codec is used wherever the guards pass. It must reproduce + // the oracle from seeds staged per tile and from seeds kept resident on + // the device. + for retain in [false, true] { + let (source, _) = bound + .prepare_trace(index, record, io, &[], (0, 0), end, rows, retain) + .unwrap(); + let mut host = vec![G::ZERO; expected.len()]; + source.write_rows(0, &mut host); + assert_eq!( + host.iter().map(|g| g.as_canonical_u64()).collect::>(), + expected, + "circuit {index}, retain {retain}: CPU mirror" + ); + for (first, rows) in [(0, height), (height - 1, height + 1)] { + let actual = source.download_tile(0, first, rows); + assert_eq!( + seed_cache_bytes(0) > 0, + retain, + "circuit {index}: seeds resident only when retained" + ); + // The tile comes back as raw words, so noncanonical device output is + // caught here rather than hidden by field equality. + for (i, &word) in actual.iter().enumerate() { + let row = (first + i / width) % height; + assert_eq!( + word, + expected[row * width + i % width], + "circuit {index}, retain {retain}, row {row}, column {}", + i % width + ); + assert!(word < G::ORDER_U64); + } + } + source.release_device(0); + assert_eq!(seed_cache_bytes(0), 0, "circuit {index}: cache released"); + } + } +} + +#[test] +fn regrouping_and_frozen_seeds() { + let mut program = (generated::PROGRAM.expected)(); + program.circuits[0].members.swap(0, 1); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for (function, args) in [ + (0, vec![G::ZERO, -G::ONE]), + (3, vec![G::ONE, G::from_u8(255)]), + (12, vec![]), + ] { + program.execute_in(function, args, &mut io, &mut record).unwrap(); + } + parity(&program, &record, &io); + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare_trace(0, &record, &io, &[], (0, 0), (3, 0), 3, false) + .unwrap(); + drop(record); + drop(io); + let mut expected = vec![G::ZERO; source.height() * source.width()]; + source.write_rows(0, &mut expected); + assert_eq!( + source.download_tile(0, 0, 4), + expected.iter().map(|g| g.as_canonical_u64()).collect::>() + ); +} + +unsafe extern "C" { + fn cudaSetDevice(device: i32) -> i32; + fn cudaMalloc(output: *mut *mut std::ffi::c_void, bytes: usize) -> i32; + fn cudaFree(output: *mut std::ffi::c_void) -> i32; + +} + +struct DeviceBuffer(*mut std::ffi::c_void); +impl DeviceBuffer { + fn new(bytes: usize) -> Self { + let mut pointer = std::ptr::null_mut(); + assert_eq!(unsafe { cudaSetDevice(0) }, 0); + assert_eq!(unsafe { cudaMalloc(&mut pointer, bytes) }, 0); + Self(pointer) + } +} +impl Drop for DeviceBuffer { + fn drop(&mut self) { + assert_eq!(unsafe { cudaFree(self.0) }, 0); + } +} + +fn synthetic_blake3(rows: usize) -> (Toplevel, QueryRecord, IOBuffer) { + let program = (blake3::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + for i in 0..rows { + let mut input = [G::ZERO; 129]; + input[0] = G::from_usize(i % 8); + for (j, value) in input[1..].iter_mut().enumerate() { + *value = G::from_usize((i * 37 + j * 19) % 256); + } + input[1] = G::from_usize(i & 255); + input[2] = G::from_usize((i >> 8) & 255); + input[3] = G::from_usize((i >> 16) & 255); + let output = [G::from_u8(42); 32]; + record.function_queries[0] + .insert( + &input, + &output, + if i % 2 == 0 { -G::ONE } else { G::from_u64(1 << 40) }, + ) + .unwrap(); + } + (program, record, io()) +} + +/// Timings of the generated BLAKE3 provider on one tile: typed against +/// canonical upload plus generation, and seed preparation against +/// materializing the same rows on the host. The retired handwritten kernel +/// measured 2.30 ms upload and 7.45 to 7.84 ms preparation on this tile. +#[test] +#[ignore = "opt-in timing of the generated BLAKE3 provider on one GPU; run with --release"] +fn blake3_generated_timing() { + use std::{hint::black_box, time::Instant}; + const ROWS: usize = 65536; + let (program, record, io) = synthetic_blake3(ROWS); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let scalar = blake3::PROGRAM.bind(&program).unwrap(); + let writer = scalar.function(0).unwrap(); + let schema = writer.schema(); + // Multiplicity, then the stage as a full word, then 160 bytes. + assert_eq!(schema.bytes, 176); + assert_eq!(schema.offsets[1], 8); + assert!(schema.offsets[2..].iter().enumerate().all(|(i, &o)| o == 16 + i)); + let canonical_stride = SeedEncoding::Canonical.stride(schema); + let mut seed = vec![0; writer.seed_words()]; + let mut typed = vec![0; ROWS * schema.bytes]; + let mut canonical = vec![0; ROWS * canonical_stride]; + for query in 0..ROWS { + writer.pack_row(&record, &io, query, &mut seed).unwrap(); + SeedEncoding::Typed + .encode( + schema, + &seed, + &mut typed[query * schema.bytes..(query + 1) * schema.bytes], + ) + .unwrap(); + SeedEncoding::Canonical + .encode( + schema, + &seed, + &mut canonical + [query * canonical_stride..(query + 1) * canonical_stride], + ) + .unwrap(); + } + let output = DeviceBuffer::new(ROWS * 533 * 8); + // Canonical seeds for a whole tile exceed the staging lease, so both + // encodings are uploaded in the chunks the runtime would use for the + // wider one, keeping the launch count equal. + let chunk = (16 * 1024 * 1024 - 8) / canonical_stride; + let upload = |seeds: &[u8], stride: usize, encoding: u32, chunk: usize| { + for first in (0..ROWS).step_by(chunk) { + let rows = chunk.min(ROWS - first); + assert_eq!( + unsafe { + blake3_cuda::aiur_trace_blake3_0( + 0, + seeds[first * stride..].as_ptr(), + encoding, + rows, + rows, + 533, + 129, + 131, + output.0.cast::().add(first * 533), + ) + }, + 0 + ) + } + }; + let prepare = || { + compiled + .prepare(0, &record, &io, &[], (0, 0), (0, ROWS), ROWS, false) + .unwrap() + }; + let (source, _) = prepare(); + let TraceSource::Generated(source) = source else { unreachable!() }; + let mut host = vec![G::ZERO; ROWS * 533]; + // Production uploads a span as one call, so the typed tile also runs in + // the spans `prepare` would cut, as the runtime's pipeline sees them. + let span = (16 * 1024 * 1024 - 8) / schema.bytes; + println!( + "strides: canonical={canonical_stride}, typed={}, typed_span_rows={span}", + schema.bytes + ); + let mut cases: [(&str, Box); 5] = [ + ( + "upload_canonical", + Box::new(|| upload(&canonical, canonical_stride, 0, chunk)), + ), + ("upload_typed", Box::new(|| upload(&typed, schema.bytes, 1, chunk))), + ("upload_typed_span", Box::new(|| upload(&typed, schema.bytes, 1, span))), + ("cpu_rows", Box::new(|| source.write_rows(0, &mut host))), + ( + "prepare_generated", + Box::new(|| { + black_box(prepare()); + }), + ), + ]; + for (_, case) in &mut cases { + for _ in 0..2 { + case(); + } + } + let mut samples = [const { Vec::new() }; 5]; + for sample in 0..9 { + let order = if sample % 2 == 0 { [0, 1, 2, 3, 4] } else { [2, 1, 0, 4, 3] }; + for index in order { + let start = Instant::now(); + (cases[index].1)(); + samples[index].push(start.elapsed().as_secs_f64() * 1000.0); + } + } + for ((name, _), sample) in cases.iter().zip(&mut samples) { + sample.sort_by(f64::total_cmp); + println!( + "{name}: rows={ROWS}, median_ms={:.4}, samples_ms={sample:?}", + sample[4] + ); + } + println!( + "typed_over_canonical_upload={:.4}, prepare_over_cpu_rows={:.4}", + samples[1][4] / samples[0][4], + samples[4][4] / samples[3][4] + ); +} + +#[test] +fn generated_sources_and_commitments_stay_on_their_device() { + use multi_stark::{ + config::StarkGenericConfig, + types::{CommitmentParameters, FriParameters, GoldilocksBlake3Config}, + }; + let cp = CommitmentParameters { log_blowup: 2, cap_height: 0 }; + let fp = FriParameters { + log_final_poly_len: 0, + max_log_arity: 1, + num_queries: 64, + commit_proof_of_work_bits: 0, + query_proof_of_work_bits: 0, + }; + let program = (blake3::PROGRAM.expected)(); + let mut io = io(); + let mut input = vec![G::ZERO]; + input.extend((0..128).map(G::from_usize)); + let (record, _) = program.execute(0, input, &mut io).unwrap(); + let count = record.function_queries[0].len(); + assert_eq!(count, 8, "one query per BLAKE3 stage"); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let (source, _) = compiled + .prepare(0, &record, &io, &[], (0, 0), (0, count), count, false) + .unwrap(); + let devices: Vec = std::env::var("AIUR_TEST_GPU_DEVICES") + .unwrap_or_else(|_| "0".into()) + .split(',') + .map(|s| s.parse().unwrap()) + .collect(); + let roots = std::thread::scope(|scope| { + let handles: Vec<_> = devices + .into_iter() + .map(|device| { + let source = source.clone(); + scope.spawn(move || { + let config = + GoldilocksBlake3Config::with_device(cp, fp, Some(device)); + let domain = + multi_stark::config::Domain::::new( + G::ONE, + 3, + ) + .unwrap(); + let (root, data) = config.commit_main(vec![(domain, source.clone())]); + drop(data); + let (regenerated, data) = config.commit_main(vec![(domain, source)]); + assert_eq!(root, regenerated); + drop(data); + root + }) + }) + .collect(); + handles.into_iter().map(|h| h.join().unwrap()).collect::>() + }); + assert!(roots.windows(2).all(|pair| pair[0] == pair[1])); +} + +#[test] +fn maximum_tile_and_wrapped_halo() { + let (program, record, io) = synthetic_blake3(65537); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let (source, _) = compiled + .prepare_trace(0, &record, &io, &[], (0, 0), (0, 65537), 65537, false) + .unwrap(); + for first in [0, 65536, 131070] { + let actual = source.download_tile(0, first, 65537); + let mut expected = vec![G::ZERO; actual.len()]; + source.write_rows(first, &mut expected); + for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() { + assert_eq!( + *actual, + expected.as_canonical_u64(), + "row {}, column {}", + i / 533, + i % 533 + ); + } + } +} + +#[test] +fn resident_seeds_serve_tiles_until_released() { + const ROWS: usize = 300_000; + let (program, record, io) = synthetic_blake3(ROWS); + let compiled = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let prepare = |retain| { + let (source, _) = compiled + .prepare_trace(0, &record, &io, &[], (0, 0), (0, ROWS), ROWS, retain) + .unwrap(); + source + }; + let staged = prepare(false); + let resident = prepare(true); + let height = ROWS.next_power_of_two(); + assert_eq!(seed_cache_bytes(0), 0); + // The rows fill five spans, so the resident copy is one allocation + // staged through the pinned ring many times over; the first tile uploads + // it, the rest reuse it. + for (first, rows) in + [(0, 65536), (65536, 65537), (ROWS - 3, 65537), (height - 1, 2)] + { + let expected = staged.download_tile(0, first, rows); + let actual = resident.download_tile(0, first, rows); + assert_eq!(actual, expected, "tile at {first}"); + assert!(seed_cache_bytes(0) >= ROWS * 176, "seeds resident after {first}"); + } + let held = seed_cache_bytes(0); + resident.release_device(1); + assert_eq!(seed_cache_bytes(0), held, "another device's release is a no-op"); + resident.release_device(0); + assert_eq!(seed_cache_bytes(0), 0); + let expected = staged.download_tile(0, 7, 9); + let actual = resident.download_tile(0, 7, 9); + assert_eq!(actual, expected, "tiles are served after a release"); + assert_eq!(seed_cache_bytes(0), held, "and the seeds are resident again"); + drop(resident); + assert_eq!(seed_cache_bytes(0), 0, "dropping the source frees its seeds"); +} + +#[test] +fn concurrent_uploads_keep_frozen_seeds() { + let devices: Vec = std::env::var("AIUR_TEST_GPU_DEVICES") + .unwrap_or_else(|_| "0".into()) + .split(',') + .map(|x| x.parse().unwrap()) + .collect(); + let (program, record, io) = synthetic_blake3(33); + let bound = blake3_cuda::CUDA.bind(&blake3::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare_trace(0, &record, &io, &[], (0, 0), (0, 33), 33, false) + .unwrap(); + let source = Arc::new(source); + let barrier = std::sync::Barrier::new(8); + std::thread::scope(|scope| { + for worker in 0..8 { + let source = source.clone(); + let barrier = &barrier; + let device = devices[worker % devices.len()]; + scope.spawn(move || { + barrier.wait(); + for first in [0, 32, 63] { + let actual = source.download_tile(device, first, 65); + let mut expected = vec![G::ZERO; actual.len()]; + source.write_rows(first, &mut expected); + assert_eq!( + actual, + expected.iter().map(|g| g.as_canonical_u64()).collect::>() + ); + } + }); + } + }); +} + +#[test] +fn device_errors_release_the_staging_lease() { + let output = DeviceBuffer::new(24); + let mut seed = [0u8; 16]; + seed[0] = 1; + seed[8] = 7; + let write = |seed: &[u8; 16], encoding| unsafe { + generated_cuda::aiur_trace_fixtures_19( + 0, + seed.as_ptr(), + encoding, + 1, + 1, + 3, + 1, + 2, + output.0.cast(), + ) + }; + // More failures than staging slots detects leases stranded by an error. + for _ in 0..8 { + assert_eq!(write(&seed, 1), 10002); + } + assert_ne!(write(&seed, 2), 0); + seed[8] = 0; + assert_eq!(write(&seed, 1), 0); +} + +#[test] +fn cuda_binding_rejects_changed_seed_layout_of_the_same_size() { + // Swap the stage word and the first message byte: same words, same 176 + // bytes, consistent offsets, different layout. The kernel would read the + // packer's bytes in the wrong places, so the schema contract must reject it. + let program = (blake3::PROGRAM.expected)(); + let mut functions = blake3::PROGRAM.functions.to_vec(); + let writer = functions[0].as_mut().unwrap(); + let mut widths = writer.schema.widths.to_vec(); + widths.swap(1, 2); + let mut offsets = vec![0; widths.len()]; + let mut cursor = 0; + for width in [SeedWidth::Full, SeedWidth::U32, SeedWidth::U16, SeedWidth::U8] + { + for (i, &w) in widths.iter().enumerate() { + if w == width { + offsets[i] = cursor; + cursor += width.bytes(); + } + } + } + let schema: &'static SeedSchema = Box::leak(Box::new(SeedSchema { + widths: Box::leak(widths.into_boxed_slice()), + offsets: Box::leak(offsets.into_boxed_slice()), + bytes: writer.schema.bytes, + })); + assert!(schema.is_consistent()); + writer.schema = schema; + let changed = Box::leak(Box::new(GeneratedProgram { + fingerprint: blake3::PROGRAM.fingerprint, + complete: true, + expected: blake3::PROGRAM.expected, + functions: Box::leak(functions.into_boxed_slice()), + })); + assert!(changed.bind(&program).is_ok(), "the layout alone is well formed"); + assert_eq!( + blake3_cuda::CUDA.bind(changed, &program).err(), + Some("CUDA unit was compiled for different seed layouts") + ); +} + +#[test] +fn cuda_binding_rejects_changed_seed_width() { + let program = (blake3::PROGRAM.expected)(); + let mut functions = blake3::PROGRAM.functions.to_vec(); + functions[0].as_mut().unwrap().seed_words = 1; + let changed = Box::leak(Box::new(GeneratedProgram { + fingerprint: blake3::PROGRAM.fingerprint, + complete: true, + expected: blake3::PROGRAM.expected, + functions: Box::leak(functions.into_boxed_slice()), + })); + assert!(blake3_cuda::CUDA.bind(changed, &program).is_err()); +} + +#[test] +fn wide_rows_widen_the_member_span_once() { + // Function 3's value input is speculatively a byte. Alternating byte rows + // through the default arm and wide rows through the multiply arm must + // produce one full-width span for the whole run, matching CPU rows, + // without retaining typed reservations. + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for i in 0..1024_u64 { + let (tag, value) = + if i % 2 == 0 { (2 + i / 256, i % 256) } else { (0, (1 << 32) + i) }; + program + .execute_in( + 3, + vec![G::from_u64(tag), G::from_u64(value)], + &mut io, + &mut record, + ) + .unwrap(); + } + assert_eq!(record.function_queries[3].len(), 1024); + let circuit = circuit_of(&program, 3); + let member = + program.circuits[circuit].members.iter().position(|&f| f == 3).unwrap(); + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare_trace( + circuit, + &record, + &io, + &[], + (member, 0), + (member, 1024), + 1024, + false, + ) + .unwrap(); + let words = bound_words(&generated::PROGRAM, 3); + assert!(source.host_bytes() >= 1024 * 8 * words); + assert!( + source.host_bytes() < 2 * 1024 * 8 * words + 1024, + "widened span retained unused reservations: {}", + source.host_bytes() + ); + let width = program.circuits[circuit].layout.width(); + let mut expected = vec![G::ZERO; 1024 * width]; + source.write_rows(0, &mut expected); + assert_eq!( + source.download_tile(0, 0, 1024), + expected.iter().map(|g| g.as_canonical_u64()).collect::>() + ); +} + +fn bound_words(program: &GeneratedProgram, function: usize) -> usize { + program.functions[function].as_ref().unwrap().seed_words +} + +#[test] +fn wide_row_in_a_later_chunk_widens_earlier_chunks() { + // Three packing chunks of function 3 rows, all bytes except one wide value + // in the third chunk, with zero-multiplicity queries scattered through the + // run. Every chunk must end up full width, rows must keep query order with + // the dead queries skipped, and the device rows must match the oracle. + const ROWS: usize = 3 * 4096 + 300; + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::new(&program); + let mut io = io(); + for i in 0..ROWS { + let (tag, value) = if i == 2 * 4096 + 777 { + (0, (1 << 32) + i) + } else { + (2 + i / 256, i % 256) + }; + program + .execute_in( + 3, + vec![G::from_usize(tag), G::from_usize(value)], + &mut io, + &mut record, + ) + .unwrap(); + } + assert_eq!(record.function_queries[3].len(), ROWS); + for dead in [0usize, 5, 4095, 4096, 9000, ROWS - 1] { + *record.function_queries[3].get_index_mut(dead).unwrap().1 = G::ZERO; + } + let live: Vec = (0..ROWS) + .filter(|&q| { + record.function_queries[3].get_index(q).unwrap().1.multiplicity != G::ZERO + }) + .collect(); + let circuit = circuit_of(&program, 3); + let member = + program.circuits[circuit].members.iter().position(|&f| f == 3).unwrap(); + let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, &program).unwrap(); + let (source, _) = bound + .prepare_trace( + circuit, + &record, + &io, + &[], + (member, 0), + (member, ROWS), + live.len(), + false, + ) + .unwrap(); + let words = bound_words(&generated::PROGRAM, 3); + assert!( + source.host_bytes() >= live.len() * 8 * words, + "the whole run is full width: {}", + source.host_bytes() + ); + let width = program.circuits[circuit].layout.width(); + let height = live.len().next_power_of_two(); + let mut expected: Vec = live + .iter() + .flat_map(|&q| program.main_row_for_test(circuit, 3, q, &record, &io)) + .map(|g| g.as_canonical_u64()) + .collect(); + expected.resize(height * width, 0); + let mut host = vec![G::ZERO; height * width]; + source.write_rows(0, &mut host); + assert_eq!( + host.iter().map(|g| g.as_canonical_u64()).collect::>(), + expected, + "CPU mirror" + ); + assert_eq!(source.download_tile(0, 0, height), expected, "device rows"); +} + +#[test] +fn memory_tables_match_the_cpu_builder() { + use crate::memory::Memory; + // Two widths, a nonzero pointer namespace, zero and negative + // multiplicities, and ranges that start past the table's first entry. + let program = (generated::PROGRAM.expected)(); + let mut record = QueryRecord::with_pointer_base(&program, 1 << 30); + for (width, entries) in [(2usize, 300usize), (10, 4097)] { + let table = record.memory_queries.get_mut(&width).unwrap(); + for i in 0..entries { + let values: Vec = (0..width) + .map(|j| G::from_u64(((i * 977 + j * 131) as u64) << 40 | i as u64)) + .collect(); + let multiplicity = match i % 3 { + 0 => G::ZERO, + 1 => -G::from_usize(i), + _ => G::from_usize(i), + }; + table + .insert( + &values, + &[G::from_usize(record.pointer_base + i)], + multiplicity, + ) + .unwrap(); + } + } + for (width, ranges) in [ + (2usize, vec![0..300, 5..300, 299..300]), + (10, vec![0..4097, 4096..4097, 13..2000]), + ] { + for range in ranges { + let (expected, _) = + Memory::witness_data_range(width, &record, &[], range.clone()); + let (source, _) = + prepare_memory_trace(&record, width, &[], range.clone()).unwrap(); + assert_eq!(source.height(), expected.height()); + let mut host = vec![G::ZERO; expected.values.len()]; + source.write_rows(0, &mut host); + assert_eq!( + host, expected.values, + "width {width}, range {range:?}: CPU mirror" + ); + let height = expected.height(); + for (first, rows) in [(0, height), (height - 1, height + 1)] { + let actual = source.download_tile(0, first, rows); + let w = width + 3; + for (i, &cell) in actual.iter().enumerate() { + let row = (first + i / w) % height; + assert_eq!( + cell, + expected.values[row * w + i % w].as_canonical_u64(), + "width {width}, range {range:?}, row {row}, column {}", + i % w + ); + } + } + } + } + assert!(prepare_memory(&record, 2, &[], 0..0).is_err()); + assert!(prepare_memory(&record, 2, &[], 0..301).is_err()); +} diff --git a/crates/aiur/src/trace_codegen/tests/generated.rs b/crates/aiur/src/trace_codegen/tests/generated.rs new file mode 100644 index 000000000..58de4c5db --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/generated.rs @@ -0,0 +1,311 @@ +// Generated by Aiur.TraceCodegen; regenerate from Aiur bytecode. +#![allow(unused_imports, unused_variables, unused_parens, unreachable_code, unused_labels)] +use crate::{G, bytecode::{Toplevel, Function, FunctionLayout, Circuit, Block, Op, Ctrl}, + execute::{g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2}, trace_codegen::*}; +use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +fn pack_0(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_0_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn write_0(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_4]: [G; 1] = [v_0 * v_1]; row[offsets.auxiliaries + 1] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = [G::from_u64(7)]; let [v_6]: [G; 1] = [v_4 * v_5]; let [v_7]: [G; 1] = [G::from_bool(v_6.is_zero())]; row[offsets.auxiliaries + 2] = g_inverse_value(v_6).as_canonical_u64(); row[offsets.auxiliaries + 3] = v_7.as_canonical_u64(); let [v_8]: [G; 1] = [G::from_bool(v_0.is_zero())]; row[offsets.auxiliaries + 4] = g_inverse_value(v_0).as_canonical_u64(); row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); let [v_9]: [G; 1] = [g_inverse_value(v_0)]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 8] = v_0.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_0: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_1(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_1_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn write_1(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9]: [G; 8] = [G::from_bool((v_0.as_canonical_u64() & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 1) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 2) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 3) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 4) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 5) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 6) & 1) != 0), G::from_bool(((v_0.as_canonical_u64() >> 7) & 1) != 0)]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); let [v_10]: [G; 1] = [Bytes1::shift_left(&v_0)]; row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [Bytes1::shift_right(&v_0)]; row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [Bytes2::xor(&v_0, &v_1)]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); let op_4 = Bytes2::add(&v_0, &v_1); let [v_13, v_14]: [G; 2] = [op_4.0, op_4.1]; row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); let op_5 = Bytes2::sub(&v_0, &v_1); let [v_15, v_16]: [G; 2] = [op_5.0, op_5.1]; row[offsets.auxiliaries + 13] = v_15.as_canonical_u64(); let op_6 = Bytes2::mul(&v_0, &v_1); let [v_17, v_18]: [G; 2] = [op_6.0, op_6.1]; row[offsets.auxiliaries + 14] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [Bytes2::and(&v_0, &v_1)]; row[offsets.auxiliaries + 16] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [Bytes2::or(&v_0, &v_1)]; row[offsets.auxiliaries + 17] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [Bytes2::less_than(&v_0, &v_1)]; row[offsets.auxiliaries + 18] = v_21.as_canonical_u64(); let op_10 = Bytes2::xor_split7(&v_0, &v_1); let [v_22, v_23]: [G; 2] = [op_10.0, op_10.1]; row[offsets.auxiliaries + 19] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_23.as_canonical_u64(); let op_11 = Bytes2::xor_split4(&v_0, &v_1); let [v_24, v_25]: [G; 2] = [op_11.0, op_11.1]; row[offsets.auxiliaries + 21] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [v_14 * v_16]; row[offsets.auxiliaries + 23] = v_26.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_1: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9], bytes: 16 }; + +fn pack_2(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn pack_2_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn write_2(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let [v_12]: [G; 1] = [G::from_u64(u32_word([v_0, v_1, v_2, v_3]))]; let [v_13]: [G; 1] = [G::from_u64(u32_word([v_4, v_5, v_6, v_7]))]; let op_2 = u32_less_than(v_12, v_13); let [v_14]: [G; 1] = [op_2.0]; row[offsets.auxiliaries + 1] = op_2.1[0].as_canonical_u64(); row[offsets.auxiliaries + 2] = op_2.1[1].as_canonical_u64(); row[offsets.auxiliaries + 3] = op_2.1[2].as_canonical_u64(); row[offsets.auxiliaries + 4] = op_2.1[3].as_canonical_u64(); row[offsets.auxiliaries + 5] = op_2.1[4].as_canonical_u64(); row[offsets.auxiliaries + 6] = op_2.1[5].as_canonical_u64(); let [v_15, v_16, v_17, v_18, v_19]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7])]); row[offsets.auxiliaries + 7] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_18.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7]), u32_word([v_8, v_9, v_10, v_11])]); row[offsets.auxiliaries + 11] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_23.as_canonical_u64(); let [v_25]: [G; 1] = [v_19 * v_24]; row[offsets.auxiliaries + 15] = v_25.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_2: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], bytes: 24 }; + +fn pack_3(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn pack_3_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; } + +fn write_3(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_2]: [G; 1] = [v_1 * v_1]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_2]; }, 1u64 => { let op_1 = Bytes2::add(&v_1, &v_1); let [v_3, v_4]: [G; 2] = [op_1.0, op_1.1]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 2] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_5]: [G; 1] = [G::from_bool(v_1.is_zero())]; row[offsets.auxiliaries + 3] = g_inverse_value(v_1).as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [v_6 * v_1]; row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); } + +static SCHEMA_3: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_4(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let [v_2]: [G; 1] = context.store(1, &[v_0, v_1])?; seed[2] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = context.call::<1>(2, 5, &[v_2])?; seed[3] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = context.load::<2>(3, v_3)?; seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_4_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let [v_2]: [G; 1] = context.store(1, &[v_0, v_1])?; seed.u32(32, v_2); let [v_3]: [G; 1] = context.call::<1>(2, 5, &[v_2])?; seed.u32(36, v_3); let [v_4, v_5]: [G; 2] = context.load::<2>(3, v_3)?; seed.full(16, v_4); seed.full(24, v_5); Ok(()) } + +fn write_4(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 3] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[4]), G::from_u64(seed[5])]; row[offsets.auxiliaries + 4] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_4: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 32, 36, 16, 24], bytes: 40 }; + +fn pack_5(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn pack_5_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; } + +fn write_5(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_5: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8], bytes: 16 }; + +fn pack_6(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_2]: [G; 1] = context.returned::<1>(1)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn pack_6_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_2]: [G; 1] = context.returned::<1>(1)?; seed.full(16, v_2); Ok(()) } + +fn write_6(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 2] = v_2.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_6: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_7(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.io_info(1, v_0, &[v_1])?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_0, v_2)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); Ok(()) } + +fn pack_7_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.io_info(1, v_0, &[v_1])?; seed.u32(40, v_2); seed.u32(44, v_3); let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_0, v_2)?; seed.full(24, v_4); seed.full(32, v_5); Ok(()) } + +fn write_7(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3]: [G; 2] = [G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[5]), G::from_u64(seed[6])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_7: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 40, 44, 24, 32], bytes: 48 }; + +fn pack_8(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn pack_8_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = [v_0 * v_0]; let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed.full(8, v_2); Ok(()) } + +fn write_8(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); return; }, _ => { row[offsets.auxiliaries + 2] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 3] = v_2.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); } + +static SCHEMA_8: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 8], bytes: 24 }; + +fn pack_9(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed[2] = v_2.as_canonical_u64(); Ok(()) } + +fn pack_9_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; match v_1.as_canonical_u64() { 0u64 => { return Ok(()); }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_2]: [G; 1] = context.load::<1>(1, v_0)?; seed.full(8, v_2); Ok(()) } + +fn write_9(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let []: [G; 0] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); return; }, _ => { row[offsets.auxiliaries + 2] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_2]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 3] = v_2.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); } + +static SCHEMA_9: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 8], bytes: 24 }; + +fn pack_10(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = context.io_read::<1>(1, v_1, v_2)?; seed[3] = v_3.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_1, v_2)?; seed[3] = v_4.as_canonical_u64(); seed[4] = v_5.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; let [v_7]: [G; 1] = context.io_read::<1>(3, v_1, v_6)?; seed[5] = v_7.as_canonical_u64(); Ok(()) } + +fn pack_10_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2]: [G; 1] = [G::from_u64(0)]; let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = context.io_read::<1>(1, v_1, v_2)?; seed.full(24, v_3); break 'yield_0 [v_3]; }, _ => { let [v_4, v_5]: [G; 2] = context.io_read::<2>(2, v_1, v_2)?; seed.full(24, v_4); seed.u32(40, v_5); break 'yield_0 [v_5]; }, } }; let [v_7]: [G; 1] = context.io_read::<1>(3, v_1, v_6)?; seed.full(32, v_7); Ok(()) } + +fn write_10(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_6]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(seed[3])]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_3]; }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4, v_5]: [G; 2] = [G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_5.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_5]; }, } }; row[offsets.auxiliaries + 4] = v_6.as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 5] = v_7.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); } + +static SCHEMA_10: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 8, 16, 24, 40, 32], bytes: 48 }; + +fn pack_11(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.big_uint(0, v_0, v_1)?; seed[3] = v_2.as_canonical_u64(); seed[4] = v_3.as_canonical_u64(); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = context.load::<10>(1, v_2)?; seed[5] = v_4.as_canonical_u64(); seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); seed[13] = v_12.as_canonical_u64(); seed[14] = v_13.as_canonical_u64(); Ok(()) } + +fn pack_11_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let [v_2, v_3]: [G; 2] = context.big_uint(0, v_0, v_1)?; seed.u32(104, v_2); seed.u32(108, v_3); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = context.load::<10>(1, v_2)?; seed.full(24, v_4); seed.full(32, v_5); seed.full(40, v_6); seed.full(48, v_7); seed.full(56, v_8); seed.full(64, v_9); seed.full(72, v_10); seed.full(80, v_11); seed.full(88, v_12); seed.full(96, v_13); Ok(()) } + +fn write_11(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let [v_2, v_3]: [G; 2] = [G::from_u64(seed[3]), G::from_u64(seed[4])]; row[offsets.auxiliaries + 1] = v_2.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_3.as_canonical_u64(); let [v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13]: [G; 10] = [G::from_u64(seed[5]), G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; row[offsets.auxiliaries + 3] = v_4.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_7.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_11: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 104, 108, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96], bytes: 112 }; + +fn pack_12(context: &SeedContext<'_>, seed: &mut [u64],) { } + +fn pack_12_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { } + +fn write_12(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_12: SeedSchema = SeedSchema { widths: &[SeedWidth::Full], offsets: &[0], bytes: 8 }; + +fn pack_14(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.returned::<1>(0)?; seed[2] = v_1.as_canonical_u64(); Ok(()) } + +fn pack_14_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1]: [G; 1] = context.returned::<1>(0)?; seed.full(16, v_1); Ok(()) } + +fn write_14(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [G::from_u64(seed[2])]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_14: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16], bytes: 24 }; + +fn pack_15(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn pack_15_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; } + +fn write_15(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let [v_1]: [G; 1] = [v_0 * v_0]; row[offsets.auxiliaries + 1] = v_1.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_15: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32], offsets: &[0, 8], bytes: 16 }; + +fn pack_16(context: &SeedContext<'_>, seed: &mut [u64],) { } + +fn pack_16_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { } + +fn write_16(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_16: SeedSchema = SeedSchema { widths: &[SeedWidth::Full], offsets: &[0], bytes: 8 }; + +fn pack_17(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed[130] = v_661.as_canonical_u64(); seed[131] = v_662.as_canonical_u64(); seed[132] = v_663.as_canonical_u64(); seed[133] = v_664.as_canonical_u64(); seed[134] = v_665.as_canonical_u64(); seed[135] = v_666.as_canonical_u64(); seed[136] = v_667.as_canonical_u64(); seed[137] = v_668.as_canonical_u64(); seed[138] = v_669.as_canonical_u64(); seed[139] = v_670.as_canonical_u64(); seed[140] = v_671.as_canonical_u64(); seed[141] = v_672.as_canonical_u64(); seed[142] = v_673.as_canonical_u64(); seed[143] = v_674.as_canonical_u64(); seed[144] = v_675.as_canonical_u64(); seed[145] = v_676.as_canonical_u64(); seed[146] = v_677.as_canonical_u64(); seed[147] = v_678.as_canonical_u64(); seed[148] = v_679.as_canonical_u64(); seed[149] = v_680.as_canonical_u64(); seed[150] = v_681.as_canonical_u64(); seed[151] = v_682.as_canonical_u64(); seed[152] = v_683.as_canonical_u64(); seed[153] = v_684.as_canonical_u64(); seed[154] = v_685.as_canonical_u64(); seed[155] = v_686.as_canonical_u64(); seed[156] = v_687.as_canonical_u64(); seed[157] = v_688.as_canonical_u64(); seed[158] = v_689.as_canonical_u64(); seed[159] = v_690.as_canonical_u64(); seed[160] = v_691.as_canonical_u64(); seed[161] = v_692.as_canonical_u64(); Ok(()) }, } } + +fn pack_17_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; let v_16 = context.inputs[16]; let v_17 = context.inputs[17]; let v_18 = context.inputs[18]; let v_19 = context.inputs[19]; let v_20 = context.inputs[20]; let v_21 = context.inputs[21]; let v_22 = context.inputs[22]; let v_23 = context.inputs[23]; let v_24 = context.inputs[24]; let v_25 = context.inputs[25]; let v_26 = context.inputs[26]; let v_27 = context.inputs[27]; let v_28 = context.inputs[28]; let v_29 = context.inputs[29]; let v_30 = context.inputs[30]; let v_31 = context.inputs[31]; let v_32 = context.inputs[32]; let v_33 = context.inputs[33]; let v_34 = context.inputs[34]; let v_35 = context.inputs[35]; let v_36 = context.inputs[36]; let v_37 = context.inputs[37]; let v_38 = context.inputs[38]; let v_39 = context.inputs[39]; let v_40 = context.inputs[40]; let v_41 = context.inputs[41]; let v_42 = context.inputs[42]; let v_43 = context.inputs[43]; let v_44 = context.inputs[44]; let v_45 = context.inputs[45]; let v_46 = context.inputs[46]; let v_47 = context.inputs[47]; let v_48 = context.inputs[48]; let v_49 = context.inputs[49]; let v_50 = context.inputs[50]; let v_51 = context.inputs[51]; let v_52 = context.inputs[52]; let v_53 = context.inputs[53]; let v_54 = context.inputs[54]; let v_55 = context.inputs[55]; let v_56 = context.inputs[56]; let v_57 = context.inputs[57]; let v_58 = context.inputs[58]; let v_59 = context.inputs[59]; let v_60 = context.inputs[60]; let v_61 = context.inputs[61]; let v_62 = context.inputs[62]; let v_63 = context.inputs[63]; let v_64 = context.inputs[64]; let v_65 = context.inputs[65]; let v_66 = context.inputs[66]; let v_67 = context.inputs[67]; let v_68 = context.inputs[68]; let v_69 = context.inputs[69]; let v_70 = context.inputs[70]; let v_71 = context.inputs[71]; let v_72 = context.inputs[72]; let v_73 = context.inputs[73]; let v_74 = context.inputs[74]; let v_75 = context.inputs[75]; let v_76 = context.inputs[76]; let v_77 = context.inputs[77]; let v_78 = context.inputs[78]; let v_79 = context.inputs[79]; let v_80 = context.inputs[80]; let v_81 = context.inputs[81]; let v_82 = context.inputs[82]; let v_83 = context.inputs[83]; let v_84 = context.inputs[84]; let v_85 = context.inputs[85]; let v_86 = context.inputs[86]; let v_87 = context.inputs[87]; let v_88 = context.inputs[88]; let v_89 = context.inputs[89]; let v_90 = context.inputs[90]; let v_91 = context.inputs[91]; let v_92 = context.inputs[92]; let v_93 = context.inputs[93]; let v_94 = context.inputs[94]; let v_95 = context.inputs[95]; let v_96 = context.inputs[96]; let v_97 = context.inputs[97]; let v_98 = context.inputs[98]; let v_99 = context.inputs[99]; let v_100 = context.inputs[100]; let v_101 = context.inputs[101]; let v_102 = context.inputs[102]; let v_103 = context.inputs[103]; let v_104 = context.inputs[104]; let v_105 = context.inputs[105]; let v_106 = context.inputs[106]; let v_107 = context.inputs[107]; let v_108 = context.inputs[108]; let v_109 = context.inputs[109]; let v_110 = context.inputs[110]; let v_111 = context.inputs[111]; let v_112 = context.inputs[112]; let v_113 = context.inputs[113]; let v_114 = context.inputs[114]; let v_115 = context.inputs[115]; let v_116 = context.inputs[116]; let v_117 = context.inputs[117]; let v_118 = context.inputs[118]; let v_119 = context.inputs[119]; let v_120 = context.inputs[120]; let v_121 = context.inputs[121]; let v_122 = context.inputs[122]; let v_123 = context.inputs[123]; let v_124 = context.inputs[124]; let v_125 = context.inputs[125]; let v_126 = context.inputs[126]; let v_127 = context.inputs[127]; let v_128 = context.inputs[128]; match v_0.as_canonical_u64() { 7u64 => { Ok(()) }, _ => { let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = context.returned::<32>(436)?; seed.u8(144, v_661); seed.u8(145, v_662); seed.u8(146, v_663); seed.u8(147, v_664); seed.u8(148, v_665); seed.u8(149, v_666); seed.u8(150, v_667); seed.u8(151, v_668); seed.u8(152, v_669); seed.u8(153, v_670); seed.u8(154, v_671); seed.u8(155, v_672); seed.u8(156, v_673); seed.u8(157, v_674); seed.u8(158, v_675); seed.u8(159, v_676); seed.u8(160, v_677); seed.u8(161, v_678); seed.u8(162, v_679); seed.u8(163, v_680); seed.u8(164, v_681); seed.u8(165, v_682); seed.u8(166, v_683); seed.u8(167, v_684); seed.u8(168, v_685); seed.u8(169, v_686); seed.u8(170, v_687); seed.u8(171, v_688); seed.u8(172, v_689); seed.u8(173, v_690); seed.u8(174, v_691); seed.u8(175, v_692); Ok(()) }, } } + +fn write_17(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let v_16 = G::from_u64(seed[17]); let v_17 = G::from_u64(seed[18]); let v_18 = G::from_u64(seed[19]); let v_19 = G::from_u64(seed[20]); let v_20 = G::from_u64(seed[21]); let v_21 = G::from_u64(seed[22]); let v_22 = G::from_u64(seed[23]); let v_23 = G::from_u64(seed[24]); let v_24 = G::from_u64(seed[25]); let v_25 = G::from_u64(seed[26]); let v_26 = G::from_u64(seed[27]); let v_27 = G::from_u64(seed[28]); let v_28 = G::from_u64(seed[29]); let v_29 = G::from_u64(seed[30]); let v_30 = G::from_u64(seed[31]); let v_31 = G::from_u64(seed[32]); let v_32 = G::from_u64(seed[33]); let v_33 = G::from_u64(seed[34]); let v_34 = G::from_u64(seed[35]); let v_35 = G::from_u64(seed[36]); let v_36 = G::from_u64(seed[37]); let v_37 = G::from_u64(seed[38]); let v_38 = G::from_u64(seed[39]); let v_39 = G::from_u64(seed[40]); let v_40 = G::from_u64(seed[41]); let v_41 = G::from_u64(seed[42]); let v_42 = G::from_u64(seed[43]); let v_43 = G::from_u64(seed[44]); let v_44 = G::from_u64(seed[45]); let v_45 = G::from_u64(seed[46]); let v_46 = G::from_u64(seed[47]); let v_47 = G::from_u64(seed[48]); let v_48 = G::from_u64(seed[49]); let v_49 = G::from_u64(seed[50]); let v_50 = G::from_u64(seed[51]); let v_51 = G::from_u64(seed[52]); let v_52 = G::from_u64(seed[53]); let v_53 = G::from_u64(seed[54]); let v_54 = G::from_u64(seed[55]); let v_55 = G::from_u64(seed[56]); let v_56 = G::from_u64(seed[57]); let v_57 = G::from_u64(seed[58]); let v_58 = G::from_u64(seed[59]); let v_59 = G::from_u64(seed[60]); let v_60 = G::from_u64(seed[61]); let v_61 = G::from_u64(seed[62]); let v_62 = G::from_u64(seed[63]); let v_63 = G::from_u64(seed[64]); let v_64 = G::from_u64(seed[65]); let v_65 = G::from_u64(seed[66]); let v_66 = G::from_u64(seed[67]); let v_67 = G::from_u64(seed[68]); let v_68 = G::from_u64(seed[69]); let v_69 = G::from_u64(seed[70]); let v_70 = G::from_u64(seed[71]); let v_71 = G::from_u64(seed[72]); let v_72 = G::from_u64(seed[73]); let v_73 = G::from_u64(seed[74]); let v_74 = G::from_u64(seed[75]); let v_75 = G::from_u64(seed[76]); let v_76 = G::from_u64(seed[77]); let v_77 = G::from_u64(seed[78]); let v_78 = G::from_u64(seed[79]); let v_79 = G::from_u64(seed[80]); let v_80 = G::from_u64(seed[81]); let v_81 = G::from_u64(seed[82]); let v_82 = G::from_u64(seed[83]); let v_83 = G::from_u64(seed[84]); let v_84 = G::from_u64(seed[85]); let v_85 = G::from_u64(seed[86]); let v_86 = G::from_u64(seed[87]); let v_87 = G::from_u64(seed[88]); let v_88 = G::from_u64(seed[89]); let v_89 = G::from_u64(seed[90]); let v_90 = G::from_u64(seed[91]); let v_91 = G::from_u64(seed[92]); let v_92 = G::from_u64(seed[93]); let v_93 = G::from_u64(seed[94]); let v_94 = G::from_u64(seed[95]); let v_95 = G::from_u64(seed[96]); let v_96 = G::from_u64(seed[97]); let v_97 = G::from_u64(seed[98]); let v_98 = G::from_u64(seed[99]); let v_99 = G::from_u64(seed[100]); let v_100 = G::from_u64(seed[101]); let v_101 = G::from_u64(seed[102]); let v_102 = G::from_u64(seed[103]); let v_103 = G::from_u64(seed[104]); let v_104 = G::from_u64(seed[105]); let v_105 = G::from_u64(seed[106]); let v_106 = G::from_u64(seed[107]); let v_107 = G::from_u64(seed[108]); let v_108 = G::from_u64(seed[109]); let v_109 = G::from_u64(seed[110]); let v_110 = G::from_u64(seed[111]); let v_111 = G::from_u64(seed[112]); let v_112 = G::from_u64(seed[113]); let v_113 = G::from_u64(seed[114]); let v_114 = G::from_u64(seed[115]); let v_115 = G::from_u64(seed[116]); let v_116 = G::from_u64(seed[117]); let v_117 = G::from_u64(seed[118]); let v_118 = G::from_u64(seed[119]); let v_119 = G::from_u64(seed[120]); let v_120 = G::from_u64(seed[121]); let v_121 = G::from_u64(seed[122]); let v_122 = G::from_u64(seed[123]); let v_123 = G::from_u64(seed[124]); let v_124 = G::from_u64(seed[125]); let v_125 = G::from_u64(seed[126]); let v_126 = G::from_u64(seed[127]); let v_127 = G::from_u64(seed[128]); let v_128 = G::from_u64(seed[129]); match v_0.as_canonical_u64() { 7u64 => { let [v_129]: [G; 1] = [Bytes2::xor(&v_1, &v_33)]; row[offsets.auxiliaries + 1] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [Bytes2::xor(&v_2, &v_34)]; row[offsets.auxiliaries + 2] = v_130.as_canonical_u64(); let [v_131]: [G; 1] = [Bytes2::xor(&v_3, &v_35)]; row[offsets.auxiliaries + 3] = v_131.as_canonical_u64(); let [v_132]: [G; 1] = [Bytes2::xor(&v_4, &v_36)]; row[offsets.auxiliaries + 4] = v_132.as_canonical_u64(); let [v_133]: [G; 1] = [Bytes2::xor(&v_5, &v_37)]; row[offsets.auxiliaries + 5] = v_133.as_canonical_u64(); let [v_134]: [G; 1] = [Bytes2::xor(&v_6, &v_38)]; row[offsets.auxiliaries + 6] = v_134.as_canonical_u64(); let [v_135]: [G; 1] = [Bytes2::xor(&v_7, &v_39)]; row[offsets.auxiliaries + 7] = v_135.as_canonical_u64(); let [v_136]: [G; 1] = [Bytes2::xor(&v_8, &v_40)]; row[offsets.auxiliaries + 8] = v_136.as_canonical_u64(); let [v_137]: [G; 1] = [Bytes2::xor(&v_9, &v_41)]; row[offsets.auxiliaries + 9] = v_137.as_canonical_u64(); let [v_138]: [G; 1] = [Bytes2::xor(&v_10, &v_42)]; row[offsets.auxiliaries + 10] = v_138.as_canonical_u64(); let [v_139]: [G; 1] = [Bytes2::xor(&v_11, &v_43)]; row[offsets.auxiliaries + 11] = v_139.as_canonical_u64(); let [v_140]: [G; 1] = [Bytes2::xor(&v_12, &v_44)]; row[offsets.auxiliaries + 12] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [Bytes2::xor(&v_13, &v_45)]; row[offsets.auxiliaries + 13] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [Bytes2::xor(&v_14, &v_46)]; row[offsets.auxiliaries + 14] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [Bytes2::xor(&v_15, &v_47)]; row[offsets.auxiliaries + 15] = v_143.as_canonical_u64(); let [v_144]: [G; 1] = [Bytes2::xor(&v_16, &v_48)]; row[offsets.auxiliaries + 16] = v_144.as_canonical_u64(); let [v_145]: [G; 1] = [Bytes2::xor(&v_17, &v_49)]; row[offsets.auxiliaries + 17] = v_145.as_canonical_u64(); let [v_146]: [G; 1] = [Bytes2::xor(&v_18, &v_50)]; row[offsets.auxiliaries + 18] = v_146.as_canonical_u64(); let [v_147]: [G; 1] = [Bytes2::xor(&v_19, &v_51)]; row[offsets.auxiliaries + 19] = v_147.as_canonical_u64(); let [v_148]: [G; 1] = [Bytes2::xor(&v_20, &v_52)]; row[offsets.auxiliaries + 20] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [Bytes2::xor(&v_21, &v_53)]; row[offsets.auxiliaries + 21] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [Bytes2::xor(&v_22, &v_54)]; row[offsets.auxiliaries + 22] = v_150.as_canonical_u64(); let [v_151]: [G; 1] = [Bytes2::xor(&v_23, &v_55)]; row[offsets.auxiliaries + 23] = v_151.as_canonical_u64(); let [v_152]: [G; 1] = [Bytes2::xor(&v_24, &v_56)]; row[offsets.auxiliaries + 24] = v_152.as_canonical_u64(); let [v_153]: [G; 1] = [Bytes2::xor(&v_25, &v_57)]; row[offsets.auxiliaries + 25] = v_153.as_canonical_u64(); let [v_154]: [G; 1] = [Bytes2::xor(&v_26, &v_58)]; row[offsets.auxiliaries + 26] = v_154.as_canonical_u64(); let [v_155]: [G; 1] = [Bytes2::xor(&v_27, &v_59)]; row[offsets.auxiliaries + 27] = v_155.as_canonical_u64(); let [v_156]: [G; 1] = [Bytes2::xor(&v_28, &v_60)]; row[offsets.auxiliaries + 28] = v_156.as_canonical_u64(); let [v_157]: [G; 1] = [Bytes2::xor(&v_29, &v_61)]; row[offsets.auxiliaries + 29] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [Bytes2::xor(&v_30, &v_62)]; row[offsets.auxiliaries + 30] = v_158.as_canonical_u64(); let [v_159]: [G; 1] = [Bytes2::xor(&v_31, &v_63)]; row[offsets.auxiliaries + 31] = v_159.as_canonical_u64(); let [v_160]: [G; 1] = [Bytes2::xor(&v_32, &v_64)]; row[offsets.auxiliaries + 32] = v_160.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_161, v_162, v_163, v_164, v_165]: [G; 5] = u32_add(&[u32_word([v_1, v_2, v_3, v_4]), u32_word([v_17, v_18, v_19, v_20]), u32_word([v_65, v_66, v_67, v_68])]); row[offsets.auxiliaries + 2] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_164.as_canonical_u64(); let [v_166]: [G; 1] = [G::from_u64(1)]; let [v_167]: [G; 1] = [v_165 - v_166]; let [v_168]: [G; 1] = [G::from_u64(2)]; let [v_169]: [G; 1] = [v_165 - v_168]; let [v_170]: [G; 1] = [v_167 * v_169]; row[offsets.auxiliaries + 6] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_165 * v_170]; row[offsets.auxiliaries + 7] = v_171.as_canonical_u64(); let [v_173]: [G; 1] = [Bytes2::xor(&v_49, &v_161)]; row[offsets.auxiliaries + 8] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [Bytes2::xor(&v_50, &v_162)]; row[offsets.auxiliaries + 9] = v_174.as_canonical_u64(); let [v_175]: [G; 1] = [Bytes2::xor(&v_51, &v_163)]; row[offsets.auxiliaries + 10] = v_175.as_canonical_u64(); let [v_176]: [G; 1] = [Bytes2::xor(&v_52, &v_164)]; row[offsets.auxiliaries + 11] = v_176.as_canonical_u64(); let [v_177, v_178, v_179, v_180, v_181]: [G; 5] = u32_add(&[u32_word([v_33, v_34, v_35, v_36]), u32_word([v_175, v_176, v_173, v_174])]); row[offsets.auxiliaries + 12] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_180.as_canonical_u64(); let [v_182]: [G; 1] = [v_181 * v_181]; row[offsets.auxiliaries + 16] = v_182.as_canonical_u64(); let op_52 = Bytes2::xor_split4(&v_17, &v_177); let [v_183, v_184]: [G; 2] = [op_52.0, op_52.1]; row[offsets.auxiliaries + 17] = v_183.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_184.as_canonical_u64(); let op_53 = Bytes2::xor_split4(&v_18, &v_178); let [v_185, v_186]: [G; 2] = [op_53.0, op_53.1]; row[offsets.auxiliaries + 19] = v_185.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_186.as_canonical_u64(); let op_54 = Bytes2::xor_split4(&v_19, &v_179); let [v_187, v_188]: [G; 2] = [op_54.0, op_54.1]; row[offsets.auxiliaries + 21] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_188.as_canonical_u64(); let op_55 = Bytes2::xor_split4(&v_20, &v_180); let [v_189, v_190]: [G; 2] = [op_55.0, op_55.1]; row[offsets.auxiliaries + 23] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_190.as_canonical_u64(); let [v_191]: [G; 1] = [v_185 + v_188]; let [v_192]: [G; 1] = [v_187 + v_190]; let [v_193]: [G; 1] = [v_189 + v_184]; let [v_194]: [G; 1] = [v_183 + v_186]; let [v_195, v_196, v_197, v_198, v_199]: [G; 5] = u32_add(&[u32_word([v_161, v_162, v_163, v_164]), u32_word([v_191, v_192, v_193, v_194]), u32_word([v_69, v_70, v_71, v_72])]); row[offsets.auxiliaries + 25] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_198.as_canonical_u64(); let [v_200]: [G; 1] = [v_199 - v_166]; let [v_201]: [G; 1] = [v_199 - v_168]; let [v_202]: [G; 1] = [v_200 * v_201]; row[offsets.auxiliaries + 29] = v_202.as_canonical_u64(); let [v_203]: [G; 1] = [v_199 * v_202]; row[offsets.auxiliaries + 30] = v_203.as_canonical_u64(); let [v_204]: [G; 1] = [Bytes2::xor(&v_175, &v_195)]; row[offsets.auxiliaries + 31] = v_204.as_canonical_u64(); let [v_205]: [G; 1] = [Bytes2::xor(&v_176, &v_196)]; row[offsets.auxiliaries + 32] = v_205.as_canonical_u64(); let [v_206]: [G; 1] = [Bytes2::xor(&v_173, &v_197)]; row[offsets.auxiliaries + 33] = v_206.as_canonical_u64(); let [v_207]: [G; 1] = [Bytes2::xor(&v_174, &v_198)]; row[offsets.auxiliaries + 34] = v_207.as_canonical_u64(); let [v_208, v_209, v_210, v_211, v_212]: [G; 5] = u32_add(&[u32_word([v_177, v_178, v_179, v_180]), u32_word([v_205, v_206, v_207, v_204])]); row[offsets.auxiliaries + 35] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_211.as_canonical_u64(); let [v_213]: [G; 1] = [v_212 * v_212]; row[offsets.auxiliaries + 39] = v_213.as_canonical_u64(); let op_77 = Bytes2::xor_split7(&v_191, &v_208); let [v_214, v_215]: [G; 2] = [op_77.0, op_77.1]; row[offsets.auxiliaries + 40] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_215.as_canonical_u64(); let op_78 = Bytes2::xor_split7(&v_192, &v_209); let [v_216, v_217]: [G; 2] = [op_78.0, op_78.1]; row[offsets.auxiliaries + 42] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_217.as_canonical_u64(); let op_79 = Bytes2::xor_split7(&v_193, &v_210); let [v_218, v_219]: [G; 2] = [op_79.0, op_79.1]; row[offsets.auxiliaries + 44] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_219.as_canonical_u64(); let op_80 = Bytes2::xor_split7(&v_194, &v_211); let [v_220, v_221]: [G; 2] = [op_80.0, op_80.1]; row[offsets.auxiliaries + 46] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_221.as_canonical_u64(); let [v_222]: [G; 1] = [v_214 + v_217]; let [v_223]: [G; 1] = [v_216 + v_219]; let [v_224]: [G; 1] = [v_218 + v_221]; let [v_225]: [G; 1] = [v_220 + v_215]; let [v_226, v_227, v_228, v_229, v_230]: [G; 5] = u32_add(&[u32_word([v_5, v_6, v_7, v_8]), u32_word([v_21, v_22, v_23, v_24]), u32_word([v_73, v_74, v_75, v_76])]); row[offsets.auxiliaries + 48] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_229.as_canonical_u64(); let [v_231]: [G; 1] = [v_230 - v_166]; let [v_232]: [G; 1] = [v_230 - v_168]; let [v_233]: [G; 1] = [v_231 * v_232]; row[offsets.auxiliaries + 52] = v_233.as_canonical_u64(); let [v_234]: [G; 1] = [v_230 * v_233]; row[offsets.auxiliaries + 53] = v_234.as_canonical_u64(); let [v_235]: [G; 1] = [Bytes2::xor(&v_53, &v_226)]; row[offsets.auxiliaries + 54] = v_235.as_canonical_u64(); let [v_236]: [G; 1] = [Bytes2::xor(&v_54, &v_227)]; row[offsets.auxiliaries + 55] = v_236.as_canonical_u64(); let [v_237]: [G; 1] = [Bytes2::xor(&v_55, &v_228)]; row[offsets.auxiliaries + 56] = v_237.as_canonical_u64(); let [v_238]: [G; 1] = [Bytes2::xor(&v_56, &v_229)]; row[offsets.auxiliaries + 57] = v_238.as_canonical_u64(); let [v_239, v_240, v_241, v_242, v_243]: [G; 5] = u32_add(&[u32_word([v_37, v_38, v_39, v_40]), u32_word([v_237, v_238, v_235, v_236])]); row[offsets.auxiliaries + 58] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_242.as_canonical_u64(); let [v_244]: [G; 1] = [v_243 * v_243]; row[offsets.auxiliaries + 62] = v_244.as_canonical_u64(); let op_102 = Bytes2::xor_split4(&v_21, &v_239); let [v_245, v_246]: [G; 2] = [op_102.0, op_102.1]; row[offsets.auxiliaries + 63] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_246.as_canonical_u64(); let op_103 = Bytes2::xor_split4(&v_22, &v_240); let [v_247, v_248]: [G; 2] = [op_103.0, op_103.1]; row[offsets.auxiliaries + 65] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_248.as_canonical_u64(); let op_104 = Bytes2::xor_split4(&v_23, &v_241); let [v_249, v_250]: [G; 2] = [op_104.0, op_104.1]; row[offsets.auxiliaries + 67] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_250.as_canonical_u64(); let op_105 = Bytes2::xor_split4(&v_24, &v_242); let [v_251, v_252]: [G; 2] = [op_105.0, op_105.1]; row[offsets.auxiliaries + 69] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_252.as_canonical_u64(); let [v_253]: [G; 1] = [v_247 + v_250]; let [v_254]: [G; 1] = [v_249 + v_252]; let [v_255]: [G; 1] = [v_251 + v_246]; let [v_256]: [G; 1] = [v_245 + v_248]; let [v_257, v_258, v_259, v_260, v_261]: [G; 5] = u32_add(&[u32_word([v_226, v_227, v_228, v_229]), u32_word([v_253, v_254, v_255, v_256]), u32_word([v_77, v_78, v_79, v_80])]); row[offsets.auxiliaries + 71] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_260.as_canonical_u64(); let [v_262]: [G; 1] = [v_261 - v_166]; let [v_263]: [G; 1] = [v_261 - v_168]; let [v_264]: [G; 1] = [v_262 * v_263]; row[offsets.auxiliaries + 75] = v_264.as_canonical_u64(); let [v_265]: [G; 1] = [v_261 * v_264]; row[offsets.auxiliaries + 76] = v_265.as_canonical_u64(); let [v_266]: [G; 1] = [Bytes2::xor(&v_237, &v_257)]; row[offsets.auxiliaries + 77] = v_266.as_canonical_u64(); let [v_267]: [G; 1] = [Bytes2::xor(&v_238, &v_258)]; row[offsets.auxiliaries + 78] = v_267.as_canonical_u64(); let [v_268]: [G; 1] = [Bytes2::xor(&v_235, &v_259)]; row[offsets.auxiliaries + 79] = v_268.as_canonical_u64(); let [v_269]: [G; 1] = [Bytes2::xor(&v_236, &v_260)]; row[offsets.auxiliaries + 80] = v_269.as_canonical_u64(); let [v_270, v_271, v_272, v_273, v_274]: [G; 5] = u32_add(&[u32_word([v_239, v_240, v_241, v_242]), u32_word([v_267, v_268, v_269, v_266])]); row[offsets.auxiliaries + 81] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_273.as_canonical_u64(); let [v_275]: [G; 1] = [v_274 * v_274]; row[offsets.auxiliaries + 85] = v_275.as_canonical_u64(); let op_127 = Bytes2::xor_split7(&v_253, &v_270); let [v_276, v_277]: [G; 2] = [op_127.0, op_127.1]; row[offsets.auxiliaries + 86] = v_276.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_277.as_canonical_u64(); let op_128 = Bytes2::xor_split7(&v_254, &v_271); let [v_278, v_279]: [G; 2] = [op_128.0, op_128.1]; row[offsets.auxiliaries + 88] = v_278.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_279.as_canonical_u64(); let op_129 = Bytes2::xor_split7(&v_255, &v_272); let [v_280, v_281]: [G; 2] = [op_129.0, op_129.1]; row[offsets.auxiliaries + 90] = v_280.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_281.as_canonical_u64(); let op_130 = Bytes2::xor_split7(&v_256, &v_273); let [v_282, v_283]: [G; 2] = [op_130.0, op_130.1]; row[offsets.auxiliaries + 92] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [v_276 + v_279]; let [v_285]: [G; 1] = [v_278 + v_281]; let [v_286]: [G; 1] = [v_280 + v_283]; let [v_287]: [G; 1] = [v_282 + v_277]; let [v_288, v_289, v_290, v_291, v_292]: [G; 5] = u32_add(&[u32_word([v_9, v_10, v_11, v_12]), u32_word([v_25, v_26, v_27, v_28]), u32_word([v_81, v_82, v_83, v_84])]); row[offsets.auxiliaries + 94] = v_288.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_289.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_290.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_291.as_canonical_u64(); let [v_293]: [G; 1] = [v_292 - v_166]; let [v_294]: [G; 1] = [v_292 - v_168]; let [v_295]: [G; 1] = [v_293 * v_294]; row[offsets.auxiliaries + 98] = v_295.as_canonical_u64(); let [v_296]: [G; 1] = [v_292 * v_295]; row[offsets.auxiliaries + 99] = v_296.as_canonical_u64(); let [v_297]: [G; 1] = [Bytes2::xor(&v_57, &v_288)]; row[offsets.auxiliaries + 100] = v_297.as_canonical_u64(); let [v_298]: [G; 1] = [Bytes2::xor(&v_58, &v_289)]; row[offsets.auxiliaries + 101] = v_298.as_canonical_u64(); let [v_299]: [G; 1] = [Bytes2::xor(&v_59, &v_290)]; row[offsets.auxiliaries + 102] = v_299.as_canonical_u64(); let [v_300]: [G; 1] = [Bytes2::xor(&v_60, &v_291)]; row[offsets.auxiliaries + 103] = v_300.as_canonical_u64(); let [v_301, v_302, v_303, v_304, v_305]: [G; 5] = u32_add(&[u32_word([v_41, v_42, v_43, v_44]), u32_word([v_299, v_300, v_297, v_298])]); row[offsets.auxiliaries + 104] = v_301.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_302.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_303.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_304.as_canonical_u64(); let [v_306]: [G; 1] = [v_305 * v_305]; row[offsets.auxiliaries + 108] = v_306.as_canonical_u64(); let op_152 = Bytes2::xor_split4(&v_25, &v_301); let [v_307, v_308]: [G; 2] = [op_152.0, op_152.1]; row[offsets.auxiliaries + 109] = v_307.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_308.as_canonical_u64(); let op_153 = Bytes2::xor_split4(&v_26, &v_302); let [v_309, v_310]: [G; 2] = [op_153.0, op_153.1]; row[offsets.auxiliaries + 111] = v_309.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_310.as_canonical_u64(); let op_154 = Bytes2::xor_split4(&v_27, &v_303); let [v_311, v_312]: [G; 2] = [op_154.0, op_154.1]; row[offsets.auxiliaries + 113] = v_311.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_312.as_canonical_u64(); let op_155 = Bytes2::xor_split4(&v_28, &v_304); let [v_313, v_314]: [G; 2] = [op_155.0, op_155.1]; row[offsets.auxiliaries + 115] = v_313.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [v_309 + v_312]; let [v_316]: [G; 1] = [v_311 + v_314]; let [v_317]: [G; 1] = [v_313 + v_308]; let [v_318]: [G; 1] = [v_307 + v_310]; let [v_319, v_320, v_321, v_322, v_323]: [G; 5] = u32_add(&[u32_word([v_288, v_289, v_290, v_291]), u32_word([v_315, v_316, v_317, v_318]), u32_word([v_85, v_86, v_87, v_88])]); row[offsets.auxiliaries + 117] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_321.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_322.as_canonical_u64(); let [v_324]: [G; 1] = [v_323 - v_166]; let [v_325]: [G; 1] = [v_323 - v_168]; let [v_326]: [G; 1] = [v_324 * v_325]; row[offsets.auxiliaries + 121] = v_326.as_canonical_u64(); let [v_327]: [G; 1] = [v_323 * v_326]; row[offsets.auxiliaries + 122] = v_327.as_canonical_u64(); let [v_328]: [G; 1] = [Bytes2::xor(&v_299, &v_319)]; row[offsets.auxiliaries + 123] = v_328.as_canonical_u64(); let [v_329]: [G; 1] = [Bytes2::xor(&v_300, &v_320)]; row[offsets.auxiliaries + 124] = v_329.as_canonical_u64(); let [v_330]: [G; 1] = [Bytes2::xor(&v_297, &v_321)]; row[offsets.auxiliaries + 125] = v_330.as_canonical_u64(); let [v_331]: [G; 1] = [Bytes2::xor(&v_298, &v_322)]; row[offsets.auxiliaries + 126] = v_331.as_canonical_u64(); let [v_332, v_333, v_334, v_335, v_336]: [G; 5] = u32_add(&[u32_word([v_301, v_302, v_303, v_304]), u32_word([v_329, v_330, v_331, v_328])]); row[offsets.auxiliaries + 127] = v_332.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_333.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_334.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_335.as_canonical_u64(); let [v_337]: [G; 1] = [v_336 * v_336]; row[offsets.auxiliaries + 131] = v_337.as_canonical_u64(); let op_177 = Bytes2::xor_split7(&v_315, &v_332); let [v_338, v_339]: [G; 2] = [op_177.0, op_177.1]; row[offsets.auxiliaries + 132] = v_338.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_339.as_canonical_u64(); let op_178 = Bytes2::xor_split7(&v_316, &v_333); let [v_340, v_341]: [G; 2] = [op_178.0, op_178.1]; row[offsets.auxiliaries + 134] = v_340.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_341.as_canonical_u64(); let op_179 = Bytes2::xor_split7(&v_317, &v_334); let [v_342, v_343]: [G; 2] = [op_179.0, op_179.1]; row[offsets.auxiliaries + 136] = v_342.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_343.as_canonical_u64(); let op_180 = Bytes2::xor_split7(&v_318, &v_335); let [v_344, v_345]: [G; 2] = [op_180.0, op_180.1]; row[offsets.auxiliaries + 138] = v_344.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_345.as_canonical_u64(); let [v_346]: [G; 1] = [v_338 + v_341]; let [v_347]: [G; 1] = [v_340 + v_343]; let [v_348]: [G; 1] = [v_342 + v_345]; let [v_349]: [G; 1] = [v_344 + v_339]; let [v_350, v_351, v_352, v_353, v_354]: [G; 5] = u32_add(&[u32_word([v_13, v_14, v_15, v_16]), u32_word([v_29, v_30, v_31, v_32]), u32_word([v_89, v_90, v_91, v_92])]); row[offsets.auxiliaries + 140] = v_350.as_canonical_u64(); row[offsets.auxiliaries + 141] = v_351.as_canonical_u64(); row[offsets.auxiliaries + 142] = v_352.as_canonical_u64(); row[offsets.auxiliaries + 143] = v_353.as_canonical_u64(); let [v_355]: [G; 1] = [v_354 - v_166]; let [v_356]: [G; 1] = [v_354 - v_168]; let [v_357]: [G; 1] = [v_355 * v_356]; row[offsets.auxiliaries + 144] = v_357.as_canonical_u64(); let [v_358]: [G; 1] = [v_354 * v_357]; row[offsets.auxiliaries + 145] = v_358.as_canonical_u64(); let [v_359]: [G; 1] = [Bytes2::xor(&v_61, &v_350)]; row[offsets.auxiliaries + 146] = v_359.as_canonical_u64(); let [v_360]: [G; 1] = [Bytes2::xor(&v_62, &v_351)]; row[offsets.auxiliaries + 147] = v_360.as_canonical_u64(); let [v_361]: [G; 1] = [Bytes2::xor(&v_63, &v_352)]; row[offsets.auxiliaries + 148] = v_361.as_canonical_u64(); let [v_362]: [G; 1] = [Bytes2::xor(&v_64, &v_353)]; row[offsets.auxiliaries + 149] = v_362.as_canonical_u64(); let [v_363, v_364, v_365, v_366, v_367]: [G; 5] = u32_add(&[u32_word([v_45, v_46, v_47, v_48]), u32_word([v_361, v_362, v_359, v_360])]); row[offsets.auxiliaries + 150] = v_363.as_canonical_u64(); row[offsets.auxiliaries + 151] = v_364.as_canonical_u64(); row[offsets.auxiliaries + 152] = v_365.as_canonical_u64(); row[offsets.auxiliaries + 153] = v_366.as_canonical_u64(); let [v_368]: [G; 1] = [v_367 * v_367]; row[offsets.auxiliaries + 154] = v_368.as_canonical_u64(); let op_202 = Bytes2::xor_split4(&v_29, &v_363); let [v_369, v_370]: [G; 2] = [op_202.0, op_202.1]; row[offsets.auxiliaries + 155] = v_369.as_canonical_u64(); row[offsets.auxiliaries + 156] = v_370.as_canonical_u64(); let op_203 = Bytes2::xor_split4(&v_30, &v_364); let [v_371, v_372]: [G; 2] = [op_203.0, op_203.1]; row[offsets.auxiliaries + 157] = v_371.as_canonical_u64(); row[offsets.auxiliaries + 158] = v_372.as_canonical_u64(); let op_204 = Bytes2::xor_split4(&v_31, &v_365); let [v_373, v_374]: [G; 2] = [op_204.0, op_204.1]; row[offsets.auxiliaries + 159] = v_373.as_canonical_u64(); row[offsets.auxiliaries + 160] = v_374.as_canonical_u64(); let op_205 = Bytes2::xor_split4(&v_32, &v_366); let [v_375, v_376]: [G; 2] = [op_205.0, op_205.1]; row[offsets.auxiliaries + 161] = v_375.as_canonical_u64(); row[offsets.auxiliaries + 162] = v_376.as_canonical_u64(); let [v_377]: [G; 1] = [v_371 + v_374]; let [v_378]: [G; 1] = [v_373 + v_376]; let [v_379]: [G; 1] = [v_375 + v_370]; let [v_380]: [G; 1] = [v_369 + v_372]; let [v_381, v_382, v_383, v_384, v_385]: [G; 5] = u32_add(&[u32_word([v_350, v_351, v_352, v_353]), u32_word([v_377, v_378, v_379, v_380]), u32_word([v_93, v_94, v_95, v_96])]); row[offsets.auxiliaries + 163] = v_381.as_canonical_u64(); row[offsets.auxiliaries + 164] = v_382.as_canonical_u64(); row[offsets.auxiliaries + 165] = v_383.as_canonical_u64(); row[offsets.auxiliaries + 166] = v_384.as_canonical_u64(); let [v_386]: [G; 1] = [v_385 - v_166]; let [v_387]: [G; 1] = [v_385 - v_168]; let [v_388]: [G; 1] = [v_386 * v_387]; row[offsets.auxiliaries + 167] = v_388.as_canonical_u64(); let [v_389]: [G; 1] = [v_385 * v_388]; row[offsets.auxiliaries + 168] = v_389.as_canonical_u64(); let [v_390]: [G; 1] = [Bytes2::xor(&v_361, &v_381)]; row[offsets.auxiliaries + 169] = v_390.as_canonical_u64(); let [v_391]: [G; 1] = [Bytes2::xor(&v_362, &v_382)]; row[offsets.auxiliaries + 170] = v_391.as_canonical_u64(); let [v_392]: [G; 1] = [Bytes2::xor(&v_359, &v_383)]; row[offsets.auxiliaries + 171] = v_392.as_canonical_u64(); let [v_393]: [G; 1] = [Bytes2::xor(&v_360, &v_384)]; row[offsets.auxiliaries + 172] = v_393.as_canonical_u64(); let [v_394, v_395, v_396, v_397, v_398]: [G; 5] = u32_add(&[u32_word([v_363, v_364, v_365, v_366]), u32_word([v_391, v_392, v_393, v_390])]); row[offsets.auxiliaries + 173] = v_394.as_canonical_u64(); row[offsets.auxiliaries + 174] = v_395.as_canonical_u64(); row[offsets.auxiliaries + 175] = v_396.as_canonical_u64(); row[offsets.auxiliaries + 176] = v_397.as_canonical_u64(); let [v_399]: [G; 1] = [v_398 * v_398]; row[offsets.auxiliaries + 177] = v_399.as_canonical_u64(); let op_227 = Bytes2::xor_split7(&v_377, &v_394); let [v_400, v_401]: [G; 2] = [op_227.0, op_227.1]; row[offsets.auxiliaries + 178] = v_400.as_canonical_u64(); row[offsets.auxiliaries + 179] = v_401.as_canonical_u64(); let op_228 = Bytes2::xor_split7(&v_378, &v_395); let [v_402, v_403]: [G; 2] = [op_228.0, op_228.1]; row[offsets.auxiliaries + 180] = v_402.as_canonical_u64(); row[offsets.auxiliaries + 181] = v_403.as_canonical_u64(); let op_229 = Bytes2::xor_split7(&v_379, &v_396); let [v_404, v_405]: [G; 2] = [op_229.0, op_229.1]; row[offsets.auxiliaries + 182] = v_404.as_canonical_u64(); row[offsets.auxiliaries + 183] = v_405.as_canonical_u64(); let op_230 = Bytes2::xor_split7(&v_380, &v_397); let [v_406, v_407]: [G; 2] = [op_230.0, op_230.1]; row[offsets.auxiliaries + 184] = v_406.as_canonical_u64(); row[offsets.auxiliaries + 185] = v_407.as_canonical_u64(); let [v_408]: [G; 1] = [v_400 + v_403]; let [v_409]: [G; 1] = [v_402 + v_405]; let [v_410]: [G; 1] = [v_404 + v_407]; let [v_411]: [G; 1] = [v_406 + v_401]; let [v_412, v_413, v_414, v_415, v_416]: [G; 5] = u32_add(&[u32_word([v_195, v_196, v_197, v_198]), u32_word([v_284, v_285, v_286, v_287]), u32_word([v_97, v_98, v_99, v_100])]); row[offsets.auxiliaries + 186] = v_412.as_canonical_u64(); row[offsets.auxiliaries + 187] = v_413.as_canonical_u64(); row[offsets.auxiliaries + 188] = v_414.as_canonical_u64(); row[offsets.auxiliaries + 189] = v_415.as_canonical_u64(); let [v_417]: [G; 1] = [v_416 - v_166]; let [v_418]: [G; 1] = [v_416 - v_168]; let [v_419]: [G; 1] = [v_417 * v_418]; row[offsets.auxiliaries + 190] = v_419.as_canonical_u64(); let [v_420]: [G; 1] = [v_416 * v_419]; row[offsets.auxiliaries + 191] = v_420.as_canonical_u64(); let [v_421]: [G; 1] = [Bytes2::xor(&v_391, &v_412)]; row[offsets.auxiliaries + 192] = v_421.as_canonical_u64(); let [v_422]: [G; 1] = [Bytes2::xor(&v_392, &v_413)]; row[offsets.auxiliaries + 193] = v_422.as_canonical_u64(); let [v_423]: [G; 1] = [Bytes2::xor(&v_393, &v_414)]; row[offsets.auxiliaries + 194] = v_423.as_canonical_u64(); let [v_424]: [G; 1] = [Bytes2::xor(&v_390, &v_415)]; row[offsets.auxiliaries + 195] = v_424.as_canonical_u64(); let [v_425, v_426, v_427, v_428, v_429]: [G; 5] = u32_add(&[u32_word([v_332, v_333, v_334, v_335]), u32_word([v_423, v_424, v_421, v_422])]); row[offsets.auxiliaries + 196] = v_425.as_canonical_u64(); row[offsets.auxiliaries + 197] = v_426.as_canonical_u64(); row[offsets.auxiliaries + 198] = v_427.as_canonical_u64(); row[offsets.auxiliaries + 199] = v_428.as_canonical_u64(); let [v_430]: [G; 1] = [v_429 * v_429]; row[offsets.auxiliaries + 200] = v_430.as_canonical_u64(); let op_252 = Bytes2::xor_split4(&v_284, &v_425); let [v_431, v_432]: [G; 2] = [op_252.0, op_252.1]; row[offsets.auxiliaries + 201] = v_431.as_canonical_u64(); row[offsets.auxiliaries + 202] = v_432.as_canonical_u64(); let op_253 = Bytes2::xor_split4(&v_285, &v_426); let [v_433, v_434]: [G; 2] = [op_253.0, op_253.1]; row[offsets.auxiliaries + 203] = v_433.as_canonical_u64(); row[offsets.auxiliaries + 204] = v_434.as_canonical_u64(); let op_254 = Bytes2::xor_split4(&v_286, &v_427); let [v_435, v_436]: [G; 2] = [op_254.0, op_254.1]; row[offsets.auxiliaries + 205] = v_435.as_canonical_u64(); row[offsets.auxiliaries + 206] = v_436.as_canonical_u64(); let op_255 = Bytes2::xor_split4(&v_287, &v_428); let [v_437, v_438]: [G; 2] = [op_255.0, op_255.1]; row[offsets.auxiliaries + 207] = v_437.as_canonical_u64(); row[offsets.auxiliaries + 208] = v_438.as_canonical_u64(); let [v_439]: [G; 1] = [v_433 + v_436]; let [v_440]: [G; 1] = [v_435 + v_438]; let [v_441]: [G; 1] = [v_437 + v_432]; let [v_442]: [G; 1] = [v_431 + v_434]; let [v_443, v_444, v_445, v_446, v_447]: [G; 5] = u32_add(&[u32_word([v_412, v_413, v_414, v_415]), u32_word([v_439, v_440, v_441, v_442]), u32_word([v_101, v_102, v_103, v_104])]); row[offsets.auxiliaries + 209] = v_443.as_canonical_u64(); row[offsets.auxiliaries + 210] = v_444.as_canonical_u64(); row[offsets.auxiliaries + 211] = v_445.as_canonical_u64(); row[offsets.auxiliaries + 212] = v_446.as_canonical_u64(); let [v_448]: [G; 1] = [v_447 - v_166]; let [v_449]: [G; 1] = [v_447 - v_168]; let [v_450]: [G; 1] = [v_448 * v_449]; row[offsets.auxiliaries + 213] = v_450.as_canonical_u64(); let [v_451]: [G; 1] = [v_447 * v_450]; row[offsets.auxiliaries + 214] = v_451.as_canonical_u64(); let [v_452]: [G; 1] = [Bytes2::xor(&v_423, &v_443)]; row[offsets.auxiliaries + 215] = v_452.as_canonical_u64(); let [v_453]: [G; 1] = [Bytes2::xor(&v_424, &v_444)]; row[offsets.auxiliaries + 216] = v_453.as_canonical_u64(); let [v_454]: [G; 1] = [Bytes2::xor(&v_421, &v_445)]; row[offsets.auxiliaries + 217] = v_454.as_canonical_u64(); let [v_455]: [G; 1] = [Bytes2::xor(&v_422, &v_446)]; row[offsets.auxiliaries + 218] = v_455.as_canonical_u64(); let [v_456, v_457, v_458, v_459, v_460]: [G; 5] = u32_add(&[u32_word([v_425, v_426, v_427, v_428]), u32_word([v_453, v_454, v_455, v_452])]); row[offsets.auxiliaries + 219] = v_456.as_canonical_u64(); row[offsets.auxiliaries + 220] = v_457.as_canonical_u64(); row[offsets.auxiliaries + 221] = v_458.as_canonical_u64(); row[offsets.auxiliaries + 222] = v_459.as_canonical_u64(); let [v_461]: [G; 1] = [v_460 * v_460]; row[offsets.auxiliaries + 223] = v_461.as_canonical_u64(); let op_277 = Bytes2::xor_split7(&v_439, &v_456); let [v_462, v_463]: [G; 2] = [op_277.0, op_277.1]; row[offsets.auxiliaries + 224] = v_462.as_canonical_u64(); row[offsets.auxiliaries + 225] = v_463.as_canonical_u64(); let op_278 = Bytes2::xor_split7(&v_440, &v_457); let [v_464, v_465]: [G; 2] = [op_278.0, op_278.1]; row[offsets.auxiliaries + 226] = v_464.as_canonical_u64(); row[offsets.auxiliaries + 227] = v_465.as_canonical_u64(); let op_279 = Bytes2::xor_split7(&v_441, &v_458); let [v_466, v_467]: [G; 2] = [op_279.0, op_279.1]; row[offsets.auxiliaries + 228] = v_466.as_canonical_u64(); row[offsets.auxiliaries + 229] = v_467.as_canonical_u64(); let op_280 = Bytes2::xor_split7(&v_442, &v_459); let [v_468, v_469]: [G; 2] = [op_280.0, op_280.1]; row[offsets.auxiliaries + 230] = v_468.as_canonical_u64(); row[offsets.auxiliaries + 231] = v_469.as_canonical_u64(); let [v_474, v_475, v_476, v_477, v_478]: [G; 5] = u32_add(&[u32_word([v_257, v_258, v_259, v_260]), u32_word([v_346, v_347, v_348, v_349]), u32_word([v_105, v_106, v_107, v_108])]); row[offsets.auxiliaries + 232] = v_474.as_canonical_u64(); row[offsets.auxiliaries + 233] = v_475.as_canonical_u64(); row[offsets.auxiliaries + 234] = v_476.as_canonical_u64(); row[offsets.auxiliaries + 235] = v_477.as_canonical_u64(); let [v_479]: [G; 1] = [v_478 - v_166]; let [v_480]: [G; 1] = [v_478 - v_168]; let [v_481]: [G; 1] = [v_479 * v_480]; row[offsets.auxiliaries + 236] = v_481.as_canonical_u64(); let [v_482]: [G; 1] = [v_478 * v_481]; row[offsets.auxiliaries + 237] = v_482.as_canonical_u64(); let [v_483]: [G; 1] = [Bytes2::xor(&v_205, &v_474)]; row[offsets.auxiliaries + 238] = v_483.as_canonical_u64(); let [v_484]: [G; 1] = [Bytes2::xor(&v_206, &v_475)]; row[offsets.auxiliaries + 239] = v_484.as_canonical_u64(); let [v_485]: [G; 1] = [Bytes2::xor(&v_207, &v_476)]; row[offsets.auxiliaries + 240] = v_485.as_canonical_u64(); let [v_486]: [G; 1] = [Bytes2::xor(&v_204, &v_477)]; row[offsets.auxiliaries + 241] = v_486.as_canonical_u64(); let [v_487, v_488, v_489, v_490, v_491]: [G; 5] = u32_add(&[u32_word([v_394, v_395, v_396, v_397]), u32_word([v_485, v_486, v_483, v_484])]); row[offsets.auxiliaries + 242] = v_487.as_canonical_u64(); row[offsets.auxiliaries + 243] = v_488.as_canonical_u64(); row[offsets.auxiliaries + 244] = v_489.as_canonical_u64(); row[offsets.auxiliaries + 245] = v_490.as_canonical_u64(); let [v_492]: [G; 1] = [v_491 * v_491]; row[offsets.auxiliaries + 246] = v_492.as_canonical_u64(); let op_302 = Bytes2::xor_split4(&v_346, &v_487); let [v_493, v_494]: [G; 2] = [op_302.0, op_302.1]; row[offsets.auxiliaries + 247] = v_493.as_canonical_u64(); row[offsets.auxiliaries + 248] = v_494.as_canonical_u64(); let op_303 = Bytes2::xor_split4(&v_347, &v_488); let [v_495, v_496]: [G; 2] = [op_303.0, op_303.1]; row[offsets.auxiliaries + 249] = v_495.as_canonical_u64(); row[offsets.auxiliaries + 250] = v_496.as_canonical_u64(); let op_304 = Bytes2::xor_split4(&v_348, &v_489); let [v_497, v_498]: [G; 2] = [op_304.0, op_304.1]; row[offsets.auxiliaries + 251] = v_497.as_canonical_u64(); row[offsets.auxiliaries + 252] = v_498.as_canonical_u64(); let op_305 = Bytes2::xor_split4(&v_349, &v_490); let [v_499, v_500]: [G; 2] = [op_305.0, op_305.1]; row[offsets.auxiliaries + 253] = v_499.as_canonical_u64(); row[offsets.auxiliaries + 254] = v_500.as_canonical_u64(); let [v_501]: [G; 1] = [v_495 + v_498]; let [v_502]: [G; 1] = [v_497 + v_500]; let [v_503]: [G; 1] = [v_499 + v_494]; let [v_504]: [G; 1] = [v_493 + v_496]; let [v_505, v_506, v_507, v_508, v_509]: [G; 5] = u32_add(&[u32_word([v_474, v_475, v_476, v_477]), u32_word([v_501, v_502, v_503, v_504]), u32_word([v_109, v_110, v_111, v_112])]); row[offsets.auxiliaries + 255] = v_505.as_canonical_u64(); row[offsets.auxiliaries + 256] = v_506.as_canonical_u64(); row[offsets.auxiliaries + 257] = v_507.as_canonical_u64(); row[offsets.auxiliaries + 258] = v_508.as_canonical_u64(); let [v_510]: [G; 1] = [v_509 - v_166]; let [v_511]: [G; 1] = [v_509 - v_168]; let [v_512]: [G; 1] = [v_510 * v_511]; row[offsets.auxiliaries + 259] = v_512.as_canonical_u64(); let [v_513]: [G; 1] = [v_509 * v_512]; row[offsets.auxiliaries + 260] = v_513.as_canonical_u64(); let [v_514]: [G; 1] = [Bytes2::xor(&v_485, &v_505)]; row[offsets.auxiliaries + 261] = v_514.as_canonical_u64(); let [v_515]: [G; 1] = [Bytes2::xor(&v_486, &v_506)]; row[offsets.auxiliaries + 262] = v_515.as_canonical_u64(); let [v_516]: [G; 1] = [Bytes2::xor(&v_483, &v_507)]; row[offsets.auxiliaries + 263] = v_516.as_canonical_u64(); let [v_517]: [G; 1] = [Bytes2::xor(&v_484, &v_508)]; row[offsets.auxiliaries + 264] = v_517.as_canonical_u64(); let [v_518, v_519, v_520, v_521, v_522]: [G; 5] = u32_add(&[u32_word([v_487, v_488, v_489, v_490]), u32_word([v_515, v_516, v_517, v_514])]); row[offsets.auxiliaries + 265] = v_518.as_canonical_u64(); row[offsets.auxiliaries + 266] = v_519.as_canonical_u64(); row[offsets.auxiliaries + 267] = v_520.as_canonical_u64(); row[offsets.auxiliaries + 268] = v_521.as_canonical_u64(); let [v_523]: [G; 1] = [v_522 * v_522]; row[offsets.auxiliaries + 269] = v_523.as_canonical_u64(); let op_327 = Bytes2::xor_split7(&v_501, &v_518); let [v_524, v_525]: [G; 2] = [op_327.0, op_327.1]; row[offsets.auxiliaries + 270] = v_524.as_canonical_u64(); row[offsets.auxiliaries + 271] = v_525.as_canonical_u64(); let op_328 = Bytes2::xor_split7(&v_502, &v_519); let [v_526, v_527]: [G; 2] = [op_328.0, op_328.1]; row[offsets.auxiliaries + 272] = v_526.as_canonical_u64(); row[offsets.auxiliaries + 273] = v_527.as_canonical_u64(); let op_329 = Bytes2::xor_split7(&v_503, &v_520); let [v_528, v_529]: [G; 2] = [op_329.0, op_329.1]; row[offsets.auxiliaries + 274] = v_528.as_canonical_u64(); row[offsets.auxiliaries + 275] = v_529.as_canonical_u64(); let op_330 = Bytes2::xor_split7(&v_504, &v_521); let [v_530, v_531]: [G; 2] = [op_330.0, op_330.1]; row[offsets.auxiliaries + 276] = v_530.as_canonical_u64(); row[offsets.auxiliaries + 277] = v_531.as_canonical_u64(); let [v_536, v_537, v_538, v_539, v_540]: [G; 5] = u32_add(&[u32_word([v_319, v_320, v_321, v_322]), u32_word([v_408, v_409, v_410, v_411]), u32_word([v_113, v_114, v_115, v_116])]); row[offsets.auxiliaries + 278] = v_536.as_canonical_u64(); row[offsets.auxiliaries + 279] = v_537.as_canonical_u64(); row[offsets.auxiliaries + 280] = v_538.as_canonical_u64(); row[offsets.auxiliaries + 281] = v_539.as_canonical_u64(); let [v_541]: [G; 1] = [v_540 - v_166]; let [v_542]: [G; 1] = [v_540 - v_168]; let [v_543]: [G; 1] = [v_541 * v_542]; row[offsets.auxiliaries + 282] = v_543.as_canonical_u64(); let [v_544]: [G; 1] = [v_540 * v_543]; row[offsets.auxiliaries + 283] = v_544.as_canonical_u64(); let [v_545]: [G; 1] = [Bytes2::xor(&v_267, &v_536)]; row[offsets.auxiliaries + 284] = v_545.as_canonical_u64(); let [v_546]: [G; 1] = [Bytes2::xor(&v_268, &v_537)]; row[offsets.auxiliaries + 285] = v_546.as_canonical_u64(); let [v_547]: [G; 1] = [Bytes2::xor(&v_269, &v_538)]; row[offsets.auxiliaries + 286] = v_547.as_canonical_u64(); let [v_548]: [G; 1] = [Bytes2::xor(&v_266, &v_539)]; row[offsets.auxiliaries + 287] = v_548.as_canonical_u64(); let [v_549, v_550, v_551, v_552, v_553]: [G; 5] = u32_add(&[u32_word([v_208, v_209, v_210, v_211]), u32_word([v_547, v_548, v_545, v_546])]); row[offsets.auxiliaries + 288] = v_549.as_canonical_u64(); row[offsets.auxiliaries + 289] = v_550.as_canonical_u64(); row[offsets.auxiliaries + 290] = v_551.as_canonical_u64(); row[offsets.auxiliaries + 291] = v_552.as_canonical_u64(); let [v_554]: [G; 1] = [v_553 * v_553]; row[offsets.auxiliaries + 292] = v_554.as_canonical_u64(); let op_352 = Bytes2::xor_split4(&v_408, &v_549); let [v_555, v_556]: [G; 2] = [op_352.0, op_352.1]; row[offsets.auxiliaries + 293] = v_555.as_canonical_u64(); row[offsets.auxiliaries + 294] = v_556.as_canonical_u64(); let op_353 = Bytes2::xor_split4(&v_409, &v_550); let [v_557, v_558]: [G; 2] = [op_353.0, op_353.1]; row[offsets.auxiliaries + 295] = v_557.as_canonical_u64(); row[offsets.auxiliaries + 296] = v_558.as_canonical_u64(); let op_354 = Bytes2::xor_split4(&v_410, &v_551); let [v_559, v_560]: [G; 2] = [op_354.0, op_354.1]; row[offsets.auxiliaries + 297] = v_559.as_canonical_u64(); row[offsets.auxiliaries + 298] = v_560.as_canonical_u64(); let op_355 = Bytes2::xor_split4(&v_411, &v_552); let [v_561, v_562]: [G; 2] = [op_355.0, op_355.1]; row[offsets.auxiliaries + 299] = v_561.as_canonical_u64(); row[offsets.auxiliaries + 300] = v_562.as_canonical_u64(); let [v_563]: [G; 1] = [v_557 + v_560]; let [v_564]: [G; 1] = [v_559 + v_562]; let [v_565]: [G; 1] = [v_561 + v_556]; let [v_566]: [G; 1] = [v_555 + v_558]; let [v_567, v_568, v_569, v_570, v_571]: [G; 5] = u32_add(&[u32_word([v_536, v_537, v_538, v_539]), u32_word([v_563, v_564, v_565, v_566]), u32_word([v_117, v_118, v_119, v_120])]); row[offsets.auxiliaries + 301] = v_567.as_canonical_u64(); row[offsets.auxiliaries + 302] = v_568.as_canonical_u64(); row[offsets.auxiliaries + 303] = v_569.as_canonical_u64(); row[offsets.auxiliaries + 304] = v_570.as_canonical_u64(); let [v_572]: [G; 1] = [v_571 - v_166]; let [v_573]: [G; 1] = [v_571 - v_168]; let [v_574]: [G; 1] = [v_572 * v_573]; row[offsets.auxiliaries + 305] = v_574.as_canonical_u64(); let [v_575]: [G; 1] = [v_571 * v_574]; row[offsets.auxiliaries + 306] = v_575.as_canonical_u64(); let [v_576]: [G; 1] = [Bytes2::xor(&v_547, &v_567)]; row[offsets.auxiliaries + 307] = v_576.as_canonical_u64(); let [v_577]: [G; 1] = [Bytes2::xor(&v_548, &v_568)]; row[offsets.auxiliaries + 308] = v_577.as_canonical_u64(); let [v_578]: [G; 1] = [Bytes2::xor(&v_545, &v_569)]; row[offsets.auxiliaries + 309] = v_578.as_canonical_u64(); let [v_579]: [G; 1] = [Bytes2::xor(&v_546, &v_570)]; row[offsets.auxiliaries + 310] = v_579.as_canonical_u64(); let [v_580, v_581, v_582, v_583, v_584]: [G; 5] = u32_add(&[u32_word([v_549, v_550, v_551, v_552]), u32_word([v_577, v_578, v_579, v_576])]); row[offsets.auxiliaries + 311] = v_580.as_canonical_u64(); row[offsets.auxiliaries + 312] = v_581.as_canonical_u64(); row[offsets.auxiliaries + 313] = v_582.as_canonical_u64(); row[offsets.auxiliaries + 314] = v_583.as_canonical_u64(); let [v_585]: [G; 1] = [v_584 * v_584]; row[offsets.auxiliaries + 315] = v_585.as_canonical_u64(); let op_377 = Bytes2::xor_split7(&v_563, &v_580); let [v_586, v_587]: [G; 2] = [op_377.0, op_377.1]; row[offsets.auxiliaries + 316] = v_586.as_canonical_u64(); row[offsets.auxiliaries + 317] = v_587.as_canonical_u64(); let op_378 = Bytes2::xor_split7(&v_564, &v_581); let [v_588, v_589]: [G; 2] = [op_378.0, op_378.1]; row[offsets.auxiliaries + 318] = v_588.as_canonical_u64(); row[offsets.auxiliaries + 319] = v_589.as_canonical_u64(); let op_379 = Bytes2::xor_split7(&v_565, &v_582); let [v_590, v_591]: [G; 2] = [op_379.0, op_379.1]; row[offsets.auxiliaries + 320] = v_590.as_canonical_u64(); row[offsets.auxiliaries + 321] = v_591.as_canonical_u64(); let op_380 = Bytes2::xor_split7(&v_566, &v_583); let [v_592, v_593]: [G; 2] = [op_380.0, op_380.1]; row[offsets.auxiliaries + 322] = v_592.as_canonical_u64(); row[offsets.auxiliaries + 323] = v_593.as_canonical_u64(); let [v_598, v_599, v_600, v_601, v_602]: [G; 5] = u32_add(&[u32_word([v_381, v_382, v_383, v_384]), u32_word([v_222, v_223, v_224, v_225]), u32_word([v_121, v_122, v_123, v_124])]); row[offsets.auxiliaries + 324] = v_598.as_canonical_u64(); row[offsets.auxiliaries + 325] = v_599.as_canonical_u64(); row[offsets.auxiliaries + 326] = v_600.as_canonical_u64(); row[offsets.auxiliaries + 327] = v_601.as_canonical_u64(); let [v_603]: [G; 1] = [v_602 - v_166]; let [v_604]: [G; 1] = [v_602 - v_168]; let [v_605]: [G; 1] = [v_603 * v_604]; row[offsets.auxiliaries + 328] = v_605.as_canonical_u64(); let [v_606]: [G; 1] = [v_602 * v_605]; row[offsets.auxiliaries + 329] = v_606.as_canonical_u64(); let [v_607]: [G; 1] = [Bytes2::xor(&v_329, &v_598)]; row[offsets.auxiliaries + 330] = v_607.as_canonical_u64(); let [v_608]: [G; 1] = [Bytes2::xor(&v_330, &v_599)]; row[offsets.auxiliaries + 331] = v_608.as_canonical_u64(); let [v_609]: [G; 1] = [Bytes2::xor(&v_331, &v_600)]; row[offsets.auxiliaries + 332] = v_609.as_canonical_u64(); let [v_610]: [G; 1] = [Bytes2::xor(&v_328, &v_601)]; row[offsets.auxiliaries + 333] = v_610.as_canonical_u64(); let [v_611, v_612, v_613, v_614, v_615]: [G; 5] = u32_add(&[u32_word([v_270, v_271, v_272, v_273]), u32_word([v_609, v_610, v_607, v_608])]); row[offsets.auxiliaries + 334] = v_611.as_canonical_u64(); row[offsets.auxiliaries + 335] = v_612.as_canonical_u64(); row[offsets.auxiliaries + 336] = v_613.as_canonical_u64(); row[offsets.auxiliaries + 337] = v_614.as_canonical_u64(); let [v_616]: [G; 1] = [v_615 * v_615]; row[offsets.auxiliaries + 338] = v_616.as_canonical_u64(); let op_402 = Bytes2::xor_split4(&v_222, &v_611); let [v_617, v_618]: [G; 2] = [op_402.0, op_402.1]; row[offsets.auxiliaries + 339] = v_617.as_canonical_u64(); row[offsets.auxiliaries + 340] = v_618.as_canonical_u64(); let op_403 = Bytes2::xor_split4(&v_223, &v_612); let [v_619, v_620]: [G; 2] = [op_403.0, op_403.1]; row[offsets.auxiliaries + 341] = v_619.as_canonical_u64(); row[offsets.auxiliaries + 342] = v_620.as_canonical_u64(); let op_404 = Bytes2::xor_split4(&v_224, &v_613); let [v_621, v_622]: [G; 2] = [op_404.0, op_404.1]; row[offsets.auxiliaries + 343] = v_621.as_canonical_u64(); row[offsets.auxiliaries + 344] = v_622.as_canonical_u64(); let op_405 = Bytes2::xor_split4(&v_225, &v_614); let [v_623, v_624]: [G; 2] = [op_405.0, op_405.1]; row[offsets.auxiliaries + 345] = v_623.as_canonical_u64(); row[offsets.auxiliaries + 346] = v_624.as_canonical_u64(); let [v_625]: [G; 1] = [v_619 + v_622]; let [v_626]: [G; 1] = [v_621 + v_624]; let [v_627]: [G; 1] = [v_623 + v_618]; let [v_628]: [G; 1] = [v_617 + v_620]; let [v_629, v_630, v_631, v_632, v_633]: [G; 5] = u32_add(&[u32_word([v_598, v_599, v_600, v_601]), u32_word([v_625, v_626, v_627, v_628]), u32_word([v_125, v_126, v_127, v_128])]); row[offsets.auxiliaries + 347] = v_629.as_canonical_u64(); row[offsets.auxiliaries + 348] = v_630.as_canonical_u64(); row[offsets.auxiliaries + 349] = v_631.as_canonical_u64(); row[offsets.auxiliaries + 350] = v_632.as_canonical_u64(); let [v_634]: [G; 1] = [v_633 - v_166]; let [v_635]: [G; 1] = [v_633 - v_168]; let [v_636]: [G; 1] = [v_634 * v_635]; row[offsets.auxiliaries + 351] = v_636.as_canonical_u64(); let [v_637]: [G; 1] = [v_633 * v_636]; row[offsets.auxiliaries + 352] = v_637.as_canonical_u64(); let [v_638]: [G; 1] = [Bytes2::xor(&v_609, &v_629)]; row[offsets.auxiliaries + 353] = v_638.as_canonical_u64(); let [v_639]: [G; 1] = [Bytes2::xor(&v_610, &v_630)]; row[offsets.auxiliaries + 354] = v_639.as_canonical_u64(); let [v_640]: [G; 1] = [Bytes2::xor(&v_607, &v_631)]; row[offsets.auxiliaries + 355] = v_640.as_canonical_u64(); let [v_641]: [G; 1] = [Bytes2::xor(&v_608, &v_632)]; row[offsets.auxiliaries + 356] = v_641.as_canonical_u64(); let [v_642, v_643, v_644, v_645, v_646]: [G; 5] = u32_add(&[u32_word([v_611, v_612, v_613, v_614]), u32_word([v_639, v_640, v_641, v_638])]); row[offsets.auxiliaries + 357] = v_642.as_canonical_u64(); row[offsets.auxiliaries + 358] = v_643.as_canonical_u64(); row[offsets.auxiliaries + 359] = v_644.as_canonical_u64(); row[offsets.auxiliaries + 360] = v_645.as_canonical_u64(); let [v_647]: [G; 1] = [v_646 * v_646]; row[offsets.auxiliaries + 361] = v_647.as_canonical_u64(); let op_427 = Bytes2::xor_split7(&v_625, &v_642); let [v_648, v_649]: [G; 2] = [op_427.0, op_427.1]; row[offsets.auxiliaries + 362] = v_648.as_canonical_u64(); row[offsets.auxiliaries + 363] = v_649.as_canonical_u64(); let op_428 = Bytes2::xor_split7(&v_626, &v_643); let [v_650, v_651]: [G; 2] = [op_428.0, op_428.1]; row[offsets.auxiliaries + 364] = v_650.as_canonical_u64(); row[offsets.auxiliaries + 365] = v_651.as_canonical_u64(); let op_429 = Bytes2::xor_split7(&v_627, &v_644); let [v_652, v_653]: [G; 2] = [op_429.0, op_429.1]; row[offsets.auxiliaries + 366] = v_652.as_canonical_u64(); row[offsets.auxiliaries + 367] = v_653.as_canonical_u64(); let op_430 = Bytes2::xor_split7(&v_628, &v_645); let [v_654, v_655]: [G; 2] = [op_430.0, op_430.1]; row[offsets.auxiliaries + 368] = v_654.as_canonical_u64(); row[offsets.auxiliaries + 369] = v_655.as_canonical_u64(); let [v_661, v_662, v_663, v_664, v_665, v_666, v_667, v_668, v_669, v_670, v_671, v_672, v_673, v_674, v_675, v_676, v_677, v_678, v_679, v_680, v_681, v_682, v_683, v_684, v_685, v_686, v_687, v_688, v_689, v_690, v_691, v_692]: [G; 32] = [G::from_u64(seed[130]), G::from_u64(seed[131]), G::from_u64(seed[132]), G::from_u64(seed[133]), G::from_u64(seed[134]), G::from_u64(seed[135]), G::from_u64(seed[136]), G::from_u64(seed[137]), G::from_u64(seed[138]), G::from_u64(seed[139]), G::from_u64(seed[140]), G::from_u64(seed[141]), G::from_u64(seed[142]), G::from_u64(seed[143]), G::from_u64(seed[144]), G::from_u64(seed[145]), G::from_u64(seed[146]), G::from_u64(seed[147]), G::from_u64(seed[148]), G::from_u64(seed[149]), G::from_u64(seed[150]), G::from_u64(seed[151]), G::from_u64(seed[152]), G::from_u64(seed[153]), G::from_u64(seed[154]), G::from_u64(seed[155]), G::from_u64(seed[156]), G::from_u64(seed[157]), G::from_u64(seed[158]), G::from_u64(seed[159]), G::from_u64(seed[160]), G::from_u64(seed[161])]; row[offsets.auxiliaries + 370] = v_661.as_canonical_u64(); row[offsets.auxiliaries + 371] = v_662.as_canonical_u64(); row[offsets.auxiliaries + 372] = v_663.as_canonical_u64(); row[offsets.auxiliaries + 373] = v_664.as_canonical_u64(); row[offsets.auxiliaries + 374] = v_665.as_canonical_u64(); row[offsets.auxiliaries + 375] = v_666.as_canonical_u64(); row[offsets.auxiliaries + 376] = v_667.as_canonical_u64(); row[offsets.auxiliaries + 377] = v_668.as_canonical_u64(); row[offsets.auxiliaries + 378] = v_669.as_canonical_u64(); row[offsets.auxiliaries + 379] = v_670.as_canonical_u64(); row[offsets.auxiliaries + 380] = v_671.as_canonical_u64(); row[offsets.auxiliaries + 381] = v_672.as_canonical_u64(); row[offsets.auxiliaries + 382] = v_673.as_canonical_u64(); row[offsets.auxiliaries + 383] = v_674.as_canonical_u64(); row[offsets.auxiliaries + 384] = v_675.as_canonical_u64(); row[offsets.auxiliaries + 385] = v_676.as_canonical_u64(); row[offsets.auxiliaries + 386] = v_677.as_canonical_u64(); row[offsets.auxiliaries + 387] = v_678.as_canonical_u64(); row[offsets.auxiliaries + 388] = v_679.as_canonical_u64(); row[offsets.auxiliaries + 389] = v_680.as_canonical_u64(); row[offsets.auxiliaries + 390] = v_681.as_canonical_u64(); row[offsets.auxiliaries + 391] = v_682.as_canonical_u64(); row[offsets.auxiliaries + 392] = v_683.as_canonical_u64(); row[offsets.auxiliaries + 393] = v_684.as_canonical_u64(); row[offsets.auxiliaries + 394] = v_685.as_canonical_u64(); row[offsets.auxiliaries + 395] = v_686.as_canonical_u64(); row[offsets.auxiliaries + 396] = v_687.as_canonical_u64(); row[offsets.auxiliaries + 397] = v_688.as_canonical_u64(); row[offsets.auxiliaries + 398] = v_689.as_canonical_u64(); row[offsets.auxiliaries + 399] = v_690.as_canonical_u64(); row[offsets.auxiliaries + 400] = v_691.as_canonical_u64(); row[offsets.auxiliaries + 401] = v_692.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } + +static SCHEMA_17: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175], bytes: 176 }; + +fn pack_18(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; break 'yield_1 [v_3]; }, _ => { let [v_4]: [G; 1] = [G::from_u64(1)]; break 'yield_1 [v_4]; }, } }; let [v_6]: [G; 1] = [v_5 + v_2]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = [G::from_u64(2)]; break 'yield_0 [v_7]; }, } }; let [v_9]: [G; 1] = context.io_read::<1>(4, v_1, v_8)?; seed[4] = v_9.as_canonical_u64(); Ok(()) } + +fn pack_18_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; break 'yield_1 [v_3]; }, _ => { let [v_4]: [G; 1] = [G::from_u64(1)]; break 'yield_1 [v_4]; }, } }; let [v_6]: [G; 1] = [v_5 + v_2]; break 'yield_0 [v_6]; }, _ => { let [v_7]: [G; 1] = [G::from_u64(2)]; break 'yield_0 [v_7]; }, } }; let [v_9]: [G; 1] = context.io_read::<1>(4, v_1, v_8)?; seed.full(32, v_9); Ok(()) } + +fn write_18(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let [v_8]: [G; 1] = 'yield_0: { match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = 'yield_1: { match v_2.as_canonical_u64() { 0u64 => { let [v_3]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_1 [v_3]; }, _ => { row[offsets.auxiliaries + 1] = (v_2 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [G::from_u64(1)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_1 [v_4]; }, } }; row[offsets.auxiliaries + 2] = v_5.as_canonical_u64(); let [v_6]: [G; 1] = [v_5 + v_2]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_6]; }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_7]: [G; 1] = [G::from_u64(2)]; row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_7]; }, } }; row[offsets.auxiliaries + 3] = v_8.as_canonical_u64(); let [v_9]: [G; 1] = [G::from_u64(seed[4])]; row[offsets.auxiliaries + 4] = v_9.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); } + +static SCHEMA_18: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 24, 32], bytes: 40 }; + +fn pack_19(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; } + +fn pack_19_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; } + +fn write_19(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) -> TraceResult<()> { let v_0 = G::from_u64(seed[1]); match v_0.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(19, v_0)) }, } } + +static SCHEMA_19: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8], offsets: &[0, 8], bytes: 16 }; + +fn pack_20(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn pack_20_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; } + +fn write_20(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let [v_12, v_13, v_14, v_15, v_16]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7])]); row[offsets.auxiliaries + 1] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_15.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21]: [G; 5] = u32_add(&[u32_word([v_0, v_1, v_2, v_3]), u32_word([v_4, v_5, v_6, v_7]), u32_word([v_8, v_9, v_10, v_11])]); row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_20.as_canonical_u64(); let [v_22]: [G; 1] = [v_16 * v_21]; row[offsets.auxiliaries + 9] = v_22.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_20: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], bytes: 24 }; + +fn pack_21(context: &SeedContext<'_>, seed: &mut [u64],) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn pack_21_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; let v_2 = context.inputs[2]; let v_3 = context.inputs[3]; let v_4 = context.inputs[4]; let v_5 = context.inputs[5]; let v_6 = context.inputs[6]; let v_7 = context.inputs[7]; let v_8 = context.inputs[8]; let v_9 = context.inputs[9]; let v_10 = context.inputs[10]; let v_11 = context.inputs[11]; let v_12 = context.inputs[12]; let v_13 = context.inputs[13]; let v_14 = context.inputs[14]; let v_15 = context.inputs[15]; } + +fn write_21(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { let v_0 = G::from_u64(seed[1]); let v_1 = G::from_u64(seed[2]); let v_2 = G::from_u64(seed[3]); let v_3 = G::from_u64(seed[4]); let v_4 = G::from_u64(seed[5]); let v_5 = G::from_u64(seed[6]); let v_6 = G::from_u64(seed[7]); let v_7 = G::from_u64(seed[8]); let v_8 = G::from_u64(seed[9]); let v_9 = G::from_u64(seed[10]); let v_10 = G::from_u64(seed[11]); let v_11 = G::from_u64(seed[12]); let v_12 = G::from_u64(seed[13]); let v_13 = G::from_u64(seed[14]); let v_14 = G::from_u64(seed[15]); let v_15 = G::from_u64(seed[16]); let [v_16]: [G; 1] = [G::from_u64(256)]; let [v_17]: [G; 1] = [v_16 * v_1]; let [v_18]: [G; 1] = [v_0 + v_17]; let [v_19]: [G; 1] = [v_16 * v_9]; let [v_20]: [G; 1] = [v_8 + v_19]; let [v_21]: [G; 1] = [v_16 * v_3]; let [v_22]: [G; 1] = [v_2 + v_21]; let [v_23]: [G; 1] = [v_16 * v_11]; let [v_24]: [G; 1] = [v_10 + v_23]; let [v_25]: [G; 1] = [v_16 * v_5]; let [v_26]: [G; 1] = [v_4 + v_25]; let [v_27]: [G; 1] = [v_16 * v_13]; let [v_28]: [G; 1] = [v_12 + v_27]; let [v_29]: [G; 1] = [v_16 * v_7]; let [v_30]: [G; 1] = [v_6 + v_29]; let [v_31]: [G; 1] = [v_16 * v_15]; let [v_32]: [G; 1] = [v_14 + v_31]; let [v_33]: [G; 1] = [v_18 * v_20]; row[offsets.auxiliaries + 1] = v_33.as_canonical_u64(); let [v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41]: [G; 8] = v_33.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 2] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_41.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(65536)]; let [v_45]: [G; 1] = [v_16 * v_37]; let [v_46]: [G; 1] = [v_44 * v_38]; let [v_47]: [G; 1] = [v_45 + v_46]; let [v_48]: [G; 1] = [v_36 + v_47]; let [v_52]: [G; 1] = [v_18 * v_24]; row[offsets.auxiliaries + 10] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [v_22 * v_20]; row[offsets.auxiliaries + 11] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [v_53 + v_48]; let [v_55]: [G; 1] = [v_52 + v_54]; let [v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 8] = v_55.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 12] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_63.as_canonical_u64(); let [v_65]: [G; 1] = [v_16 * v_59]; let [v_66]: [G; 1] = [v_44 * v_60]; let [v_67]: [G; 1] = [v_65 + v_66]; let [v_68]: [G; 1] = [v_58 + v_67]; let [v_72]: [G; 1] = [v_18 * v_28]; row[offsets.auxiliaries + 20] = v_72.as_canonical_u64(); let [v_73]: [G; 1] = [v_22 * v_24]; row[offsets.auxiliaries + 21] = v_73.as_canonical_u64(); let [v_74]: [G; 1] = [v_26 * v_20]; row[offsets.auxiliaries + 22] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [v_74 + v_68]; let [v_76]: [G; 1] = [v_73 + v_75]; let [v_77]: [G; 1] = [v_72 + v_76]; let [v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 8] = v_77.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 23] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_85.as_canonical_u64(); let [v_87]: [G; 1] = [v_16 * v_81]; let [v_88]: [G; 1] = [v_44 * v_82]; let [v_89]: [G; 1] = [v_87 + v_88]; let [v_90]: [G; 1] = [v_80 + v_89]; let [v_94]: [G; 1] = [v_18 * v_32]; row[offsets.auxiliaries + 31] = v_94.as_canonical_u64(); let [v_95]: [G; 1] = [v_22 * v_28]; row[offsets.auxiliaries + 32] = v_95.as_canonical_u64(); let [v_96]: [G; 1] = [v_26 * v_24]; row[offsets.auxiliaries + 33] = v_96.as_canonical_u64(); let [v_97]: [G; 1] = [v_30 * v_20]; row[offsets.auxiliaries + 34] = v_97.as_canonical_u64(); let [v_98]: [G; 1] = [v_97 + v_90]; let [v_99]: [G; 1] = [v_96 + v_98]; let [v_100]: [G; 1] = [v_95 + v_99]; let [v_101]: [G; 1] = [v_94 + v_100]; let [v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109]: [G; 8] = v_101.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 35] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_109.as_canonical_u64(); let [v_111]: [G; 1] = [v_16 * v_105]; let [v_112]: [G; 1] = [v_44 * v_106]; let [v_113]: [G; 1] = [v_111 + v_112]; let [v_114]: [G; 1] = [v_104 + v_113]; let [v_118]: [G; 1] = [v_22 * v_32]; row[offsets.auxiliaries + 43] = v_118.as_canonical_u64(); let [v_119]: [G; 1] = [v_26 * v_28]; row[offsets.auxiliaries + 44] = v_119.as_canonical_u64(); let [v_120]: [G; 1] = [v_30 * v_24]; row[offsets.auxiliaries + 45] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = [v_120 + v_114]; let [v_122]: [G; 1] = [v_119 + v_121]; let [v_123]: [G; 1] = [v_118 + v_122]; let [v_124, v_125, v_126, v_127, v_128, v_129, v_130, v_131]: [G; 8] = v_123.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 46] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_129.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_130.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_131.as_canonical_u64(); let [v_133]: [G; 1] = [v_16 * v_127]; let [v_134]: [G; 1] = [v_44 * v_128]; let [v_135]: [G; 1] = [v_133 + v_134]; let [v_136]: [G; 1] = [v_126 + v_135]; let [v_140]: [G; 1] = [v_26 * v_32]; row[offsets.auxiliaries + 54] = v_140.as_canonical_u64(); let [v_141]: [G; 1] = [v_30 * v_28]; row[offsets.auxiliaries + 55] = v_141.as_canonical_u64(); let [v_142]: [G; 1] = [v_141 + v_136]; let [v_143]: [G; 1] = [v_140 + v_142]; let [v_144, v_145, v_146, v_147, v_148, v_149, v_150, v_151]: [G; 8] = v_143.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 56] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_151.as_canonical_u64(); let [v_153]: [G; 1] = [v_16 * v_147]; let [v_154]: [G; 1] = [v_44 * v_148]; let [v_155]: [G; 1] = [v_153 + v_154]; let [v_156]: [G; 1] = [v_146 + v_155]; let [v_160]: [G; 1] = [v_30 * v_32]; row[offsets.auxiliaries + 64] = v_160.as_canonical_u64(); let [v_161]: [G; 1] = [v_160 + v_156]; let [v_162, v_163, v_164, v_165, v_166, v_167, v_168, v_169]: [G; 8] = v_161.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 65] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_169.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } + +static SCHEMA_21: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128], bytes: 136 }; + +#[inline(never)] +fn expected_function_0() -> Function { + Function { body: Block { ops: vec![Op::Add(0, 1), Op::Sub(0, 1), Op::Mul(0, 1), Op::Const(G::from_u64(7)), Op::Mul(4, 5), Op::EqZero(6), Op::EqZero(0), Op::UnconstrainedGInverse(0), Op::UnconstrainedGToBytes(0)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_1() -> Function { + Function { body: Block { ops: vec![Op::U8BitDecomposition(0), Op::U8ShiftLeft(0), Op::U8ShiftRight(0), Op::U8Xor(0, 1), Op::U8Add(0, 1), Op::U8Sub(0, 1), Op::U8Mul(0, 1), Op::U8And(0, 1), Op::U8Or(0, 1), Op::U8LessThan(0, 1), Op::U8XorSplit7(0, 1), Op::U8XorSplit4(0, 1), Op::U8RangeCheck(0, 1), Op::Mul(14, 16)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 24, lookups: 14 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_2() -> Function { + Function { body: Block { ops: vec![Op::U32ToField(vec![0, 1, 2, 3]), Op::U32ToField(vec![4, 5, 6, 7]), Op::U32LessThan(12, 13), Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::Mul(19, 24)], ctrl: Ctrl::Return(0, vec![12, 13, 14, 19, 24]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 16, lookups: 7 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_3() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Mul(1, 1)], ctrl: Ctrl::Yield(0, vec![2]) }), (G::from_u64(1), Block { ops: vec![Op::U8Add(1, 1)], ctrl: Ctrl::Yield(1, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::EqZero(1)], ctrl: Ctrl::Yield(2, vec![2]) })), 1, 4, 1, Box::new(Block { ops: vec![Op::Mul(2, 1)], ctrl: Ctrl::Return(3, vec![3]) })) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_4() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Store(vec![0, 1]), Op::Call(5, vec![2], 1, false), Op::Load(2, 3), Op::Add(4, 5)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_5() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_6() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Call(5, vec![1], 1, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_7() -> Function { + Function { body: Block { ops: vec![Op::IOWrite(0, vec![1]), Op::IOGetInfo(0, vec![1]), Op::IORead(0, 2, 2), Op::Const(G::from_u64(999)), Op::IOSetInfo(0, vec![6], 2, 3), Op::AssertEq(vec![4], vec![4], Some("quoted \"value\"\nλ".into())), Op::Debug("trace fixture".into(), None)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_8() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0)], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 0, Box::new(Block { ops: vec![Op::Load(1, 0)], ctrl: Ctrl::Return(2, vec![]) })) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 4, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_9() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Mul(0, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) })), 0, 2, 0, Box::new(Block { ops: vec![Op::Load(1, 0)], ctrl: Ctrl::Return(3, vec![]) })) }, layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 4, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_10() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::IORead(1, 2, 1)], ctrl: Ctrl::Yield(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::IORead(1, 2, 2)], ctrl: Ctrl::Yield(1, vec![4]) })), 1, 3, 0, Box::new(Block { ops: vec![Op::IORead(1, 3, 1)], ctrl: Ctrl::Return(2, vec![4]) })) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_11() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedBigUintDivMod(0, 1), Op::Load(10, 2)], ctrl: Ctrl::Return(0, vec![2, 3]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 13, lookups: 2 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_12() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::EqZero(0), Op::Const(G::from_u64(18446744069414584320)), Op::EqZero(2)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_13() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedGInverse(0)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: true, constrained: false } +} + +#[inline(never)] +fn expected_function_14() -> Function { + Function { body: Block { ops: vec![Op::Call(13, vec![0], 1, true)], ctrl: Ctrl::Return(0, vec![1]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_15() -> Function { + Function { body: Block { ops: vec![Op::Mul(0, 0), Op::Call(16, vec![], 0, false), Op::Load(0, 0), Op::IORead(0, 0, 0)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_16() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_17() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::U8Xor(1, 33), Op::U8Xor(2, 34), Op::U8Xor(3, 35), Op::U8Xor(4, 36), Op::U8Xor(5, 37), Op::U8Xor(6, 38), Op::U8Xor(7, 39), Op::U8Xor(8, 40), Op::U8Xor(9, 41), Op::U8Xor(10, 42), Op::U8Xor(11, 43), Op::U8Xor(12, 44), Op::U8Xor(13, 45), Op::U8Xor(14, 46), Op::U8Xor(15, 47), Op::U8Xor(16, 48), Op::U8Xor(17, 49), Op::U8Xor(18, 50), Op::U8Xor(19, 51), Op::U8Xor(20, 52), Op::U8Xor(21, 53), Op::U8Xor(22, 54), Op::U8Xor(23, 55), Op::U8Xor(24, 56), Op::U8Xor(25, 57), Op::U8Xor(26, 58), Op::U8Xor(27, 59), Op::U8Xor(28, 60), Op::U8Xor(29, 61), Op::U8Xor(30, 62), Op::U8Xor(31, 63), Op::U8Xor(32, 64)], ctrl: Ctrl::Return(0, vec![129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::UnconstrainedU32Add3(vec![1, 2, 3, 4], vec![17, 18, 19, 20], vec![65, 66, 67, 68]), Op::U8RangeCheck(129, 130), Op::U8RangeCheck(131, 132), Op::Const(G::from_u64(1)), Op::Sub(133, 134), Op::Const(G::from_u64(2)), Op::Sub(133, 136), Op::Mul(135, 137), Op::Mul(133, 138), Op::Const(G::from_u64(0)), Op::AssertEq(vec![139], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(49, 129), Op::U8Xor(50, 130), Op::U8Xor(51, 131), Op::U8Xor(52, 132), Op::UnconstrainedU32Add(vec![33, 34, 35, 36], vec![143, 144, 141, 142]), Op::U8RangeCheck(145, 146), Op::U8RangeCheck(147, 148), Op::Mul(149, 149), Op::AssertEq(vec![150], vec![149], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(17, 145), Op::U8XorSplit4(18, 146), Op::U8XorSplit4(19, 147), Op::U8XorSplit4(20, 148), Op::Add(153, 156), Op::Add(155, 158), Op::Add(157, 152), Op::Add(151, 154), Op::UnconstrainedU32Add3(vec![129, 130, 131, 132], vec![159, 160, 161, 162], vec![69, 70, 71, 72]), Op::U8RangeCheck(163, 164), Op::U8RangeCheck(165, 166), Op::Sub(167, 134), Op::Sub(167, 136), Op::Mul(168, 169), Op::Mul(167, 170), Op::AssertEq(vec![171], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(143, 163), Op::U8Xor(144, 164), Op::U8Xor(141, 165), Op::U8Xor(142, 166), Op::UnconstrainedU32Add(vec![145, 146, 147, 148], vec![173, 174, 175, 172]), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 179), Op::Mul(180, 180), Op::AssertEq(vec![181], vec![180], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(159, 176), Op::U8XorSplit7(160, 177), Op::U8XorSplit7(161, 178), Op::U8XorSplit7(162, 179), Op::Add(182, 185), Op::Add(184, 187), Op::Add(186, 189), Op::Add(188, 183), Op::UnconstrainedU32Add3(vec![5, 6, 7, 8], vec![21, 22, 23, 24], vec![73, 74, 75, 76]), Op::U8RangeCheck(194, 195), Op::U8RangeCheck(196, 197), Op::Sub(198, 134), Op::Sub(198, 136), Op::Mul(199, 200), Op::Mul(198, 201), Op::AssertEq(vec![202], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(53, 194), Op::U8Xor(54, 195), Op::U8Xor(55, 196), Op::U8Xor(56, 197), Op::UnconstrainedU32Add(vec![37, 38, 39, 40], vec![205, 206, 203, 204]), Op::U8RangeCheck(207, 208), Op::U8RangeCheck(209, 210), Op::Mul(211, 211), Op::AssertEq(vec![212], vec![211], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(21, 207), Op::U8XorSplit4(22, 208), Op::U8XorSplit4(23, 209), Op::U8XorSplit4(24, 210), Op::Add(215, 218), Op::Add(217, 220), Op::Add(219, 214), Op::Add(213, 216), Op::UnconstrainedU32Add3(vec![194, 195, 196, 197], vec![221, 222, 223, 224], vec![77, 78, 79, 80]), Op::U8RangeCheck(225, 226), Op::U8RangeCheck(227, 228), Op::Sub(229, 134), Op::Sub(229, 136), Op::Mul(230, 231), Op::Mul(229, 232), Op::AssertEq(vec![233], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(205, 225), Op::U8Xor(206, 226), Op::U8Xor(203, 227), Op::U8Xor(204, 228), Op::UnconstrainedU32Add(vec![207, 208, 209, 210], vec![235, 236, 237, 234]), Op::U8RangeCheck(238, 239), Op::U8RangeCheck(240, 241), Op::Mul(242, 242), Op::AssertEq(vec![243], vec![242], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(221, 238), Op::U8XorSplit7(222, 239), Op::U8XorSplit7(223, 240), Op::U8XorSplit7(224, 241), Op::Add(244, 247), Op::Add(246, 249), Op::Add(248, 251), Op::Add(250, 245), Op::UnconstrainedU32Add3(vec![9, 10, 11, 12], vec![25, 26, 27, 28], vec![81, 82, 83, 84]), Op::U8RangeCheck(256, 257), Op::U8RangeCheck(258, 259), Op::Sub(260, 134), Op::Sub(260, 136), Op::Mul(261, 262), Op::Mul(260, 263), Op::AssertEq(vec![264], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(57, 256), Op::U8Xor(58, 257), Op::U8Xor(59, 258), Op::U8Xor(60, 259), Op::UnconstrainedU32Add(vec![41, 42, 43, 44], vec![267, 268, 265, 266]), Op::U8RangeCheck(269, 270), Op::U8RangeCheck(271, 272), Op::Mul(273, 273), Op::AssertEq(vec![274], vec![273], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(25, 269), Op::U8XorSplit4(26, 270), Op::U8XorSplit4(27, 271), Op::U8XorSplit4(28, 272), Op::Add(277, 280), Op::Add(279, 282), Op::Add(281, 276), Op::Add(275, 278), Op::UnconstrainedU32Add3(vec![256, 257, 258, 259], vec![283, 284, 285, 286], vec![85, 86, 87, 88]), Op::U8RangeCheck(287, 288), Op::U8RangeCheck(289, 290), Op::Sub(291, 134), Op::Sub(291, 136), Op::Mul(292, 293), Op::Mul(291, 294), Op::AssertEq(vec![295], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(267, 287), Op::U8Xor(268, 288), Op::U8Xor(265, 289), Op::U8Xor(266, 290), Op::UnconstrainedU32Add(vec![269, 270, 271, 272], vec![297, 298, 299, 296]), Op::U8RangeCheck(300, 301), Op::U8RangeCheck(302, 303), Op::Mul(304, 304), Op::AssertEq(vec![305], vec![304], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(283, 300), Op::U8XorSplit7(284, 301), Op::U8XorSplit7(285, 302), Op::U8XorSplit7(286, 303), Op::Add(306, 309), Op::Add(308, 311), Op::Add(310, 313), Op::Add(312, 307), Op::UnconstrainedU32Add3(vec![13, 14, 15, 16], vec![29, 30, 31, 32], vec![89, 90, 91, 92]), Op::U8RangeCheck(318, 319), Op::U8RangeCheck(320, 321), Op::Sub(322, 134), Op::Sub(322, 136), Op::Mul(323, 324), Op::Mul(322, 325), Op::AssertEq(vec![326], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(61, 318), Op::U8Xor(62, 319), Op::U8Xor(63, 320), Op::U8Xor(64, 321), Op::UnconstrainedU32Add(vec![45, 46, 47, 48], vec![329, 330, 327, 328]), Op::U8RangeCheck(331, 332), Op::U8RangeCheck(333, 334), Op::Mul(335, 335), Op::AssertEq(vec![336], vec![335], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(29, 331), Op::U8XorSplit4(30, 332), Op::U8XorSplit4(31, 333), Op::U8XorSplit4(32, 334), Op::Add(339, 342), Op::Add(341, 344), Op::Add(343, 338), Op::Add(337, 340), Op::UnconstrainedU32Add3(vec![318, 319, 320, 321], vec![345, 346, 347, 348], vec![93, 94, 95, 96]), Op::U8RangeCheck(349, 350), Op::U8RangeCheck(351, 352), Op::Sub(353, 134), Op::Sub(353, 136), Op::Mul(354, 355), Op::Mul(353, 356), Op::AssertEq(vec![357], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(329, 349), Op::U8Xor(330, 350), Op::U8Xor(327, 351), Op::U8Xor(328, 352), Op::UnconstrainedU32Add(vec![331, 332, 333, 334], vec![359, 360, 361, 358]), Op::U8RangeCheck(362, 363), Op::U8RangeCheck(364, 365), Op::Mul(366, 366), Op::AssertEq(vec![367], vec![366], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(345, 362), Op::U8XorSplit7(346, 363), Op::U8XorSplit7(347, 364), Op::U8XorSplit7(348, 365), Op::Add(368, 371), Op::Add(370, 373), Op::Add(372, 375), Op::Add(374, 369), Op::UnconstrainedU32Add3(vec![163, 164, 165, 166], vec![252, 253, 254, 255], vec![97, 98, 99, 100]), Op::U8RangeCheck(380, 381), Op::U8RangeCheck(382, 383), Op::Sub(384, 134), Op::Sub(384, 136), Op::Mul(385, 386), Op::Mul(384, 387), Op::AssertEq(vec![388], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(359, 380), Op::U8Xor(360, 381), Op::U8Xor(361, 382), Op::U8Xor(358, 383), Op::UnconstrainedU32Add(vec![300, 301, 302, 303], vec![391, 392, 389, 390]), Op::U8RangeCheck(393, 394), Op::U8RangeCheck(395, 396), Op::Mul(397, 397), Op::AssertEq(vec![398], vec![397], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(252, 393), Op::U8XorSplit4(253, 394), Op::U8XorSplit4(254, 395), Op::U8XorSplit4(255, 396), Op::Add(401, 404), Op::Add(403, 406), Op::Add(405, 400), Op::Add(399, 402), Op::UnconstrainedU32Add3(vec![380, 381, 382, 383], vec![407, 408, 409, 410], vec![101, 102, 103, 104]), Op::U8RangeCheck(411, 412), Op::U8RangeCheck(413, 414), Op::Sub(415, 134), Op::Sub(415, 136), Op::Mul(416, 417), Op::Mul(415, 418), Op::AssertEq(vec![419], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(391, 411), Op::U8Xor(392, 412), Op::U8Xor(389, 413), Op::U8Xor(390, 414), Op::UnconstrainedU32Add(vec![393, 394, 395, 396], vec![421, 422, 423, 420]), Op::U8RangeCheck(424, 425), Op::U8RangeCheck(426, 427), Op::Mul(428, 428), Op::AssertEq(vec![429], vec![428], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(407, 424), Op::U8XorSplit7(408, 425), Op::U8XorSplit7(409, 426), Op::U8XorSplit7(410, 427), Op::Add(430, 433), Op::Add(432, 435), Op::Add(434, 437), Op::Add(436, 431), Op::UnconstrainedU32Add3(vec![225, 226, 227, 228], vec![314, 315, 316, 317], vec![105, 106, 107, 108]), Op::U8RangeCheck(442, 443), Op::U8RangeCheck(444, 445), Op::Sub(446, 134), Op::Sub(446, 136), Op::Mul(447, 448), Op::Mul(446, 449), Op::AssertEq(vec![450], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(173, 442), Op::U8Xor(174, 443), Op::U8Xor(175, 444), Op::U8Xor(172, 445), Op::UnconstrainedU32Add(vec![362, 363, 364, 365], vec![453, 454, 451, 452]), Op::U8RangeCheck(455, 456), Op::U8RangeCheck(457, 458), Op::Mul(459, 459), Op::AssertEq(vec![460], vec![459], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(314, 455), Op::U8XorSplit4(315, 456), Op::U8XorSplit4(316, 457), Op::U8XorSplit4(317, 458), Op::Add(463, 466), Op::Add(465, 468), Op::Add(467, 462), Op::Add(461, 464), Op::UnconstrainedU32Add3(vec![442, 443, 444, 445], vec![469, 470, 471, 472], vec![109, 110, 111, 112]), Op::U8RangeCheck(473, 474), Op::U8RangeCheck(475, 476), Op::Sub(477, 134), Op::Sub(477, 136), Op::Mul(478, 479), Op::Mul(477, 480), Op::AssertEq(vec![481], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(453, 473), Op::U8Xor(454, 474), Op::U8Xor(451, 475), Op::U8Xor(452, 476), Op::UnconstrainedU32Add(vec![455, 456, 457, 458], vec![483, 484, 485, 482]), Op::U8RangeCheck(486, 487), Op::U8RangeCheck(488, 489), Op::Mul(490, 490), Op::AssertEq(vec![491], vec![490], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(469, 486), Op::U8XorSplit7(470, 487), Op::U8XorSplit7(471, 488), Op::U8XorSplit7(472, 489), Op::Add(492, 495), Op::Add(494, 497), Op::Add(496, 499), Op::Add(498, 493), Op::UnconstrainedU32Add3(vec![287, 288, 289, 290], vec![376, 377, 378, 379], vec![113, 114, 115, 116]), Op::U8RangeCheck(504, 505), Op::U8RangeCheck(506, 507), Op::Sub(508, 134), Op::Sub(508, 136), Op::Mul(509, 510), Op::Mul(508, 511), Op::AssertEq(vec![512], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(235, 504), Op::U8Xor(236, 505), Op::U8Xor(237, 506), Op::U8Xor(234, 507), Op::UnconstrainedU32Add(vec![176, 177, 178, 179], vec![515, 516, 513, 514]), Op::U8RangeCheck(517, 518), Op::U8RangeCheck(519, 520), Op::Mul(521, 521), Op::AssertEq(vec![522], vec![521], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(376, 517), Op::U8XorSplit4(377, 518), Op::U8XorSplit4(378, 519), Op::U8XorSplit4(379, 520), Op::Add(525, 528), Op::Add(527, 530), Op::Add(529, 524), Op::Add(523, 526), Op::UnconstrainedU32Add3(vec![504, 505, 506, 507], vec![531, 532, 533, 534], vec![117, 118, 119, 120]), Op::U8RangeCheck(535, 536), Op::U8RangeCheck(537, 538), Op::Sub(539, 134), Op::Sub(539, 136), Op::Mul(540, 541), Op::Mul(539, 542), Op::AssertEq(vec![543], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(515, 535), Op::U8Xor(516, 536), Op::U8Xor(513, 537), Op::U8Xor(514, 538), Op::UnconstrainedU32Add(vec![517, 518, 519, 520], vec![545, 546, 547, 544]), Op::U8RangeCheck(548, 549), Op::U8RangeCheck(550, 551), Op::Mul(552, 552), Op::AssertEq(vec![553], vec![552], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(531, 548), Op::U8XorSplit7(532, 549), Op::U8XorSplit7(533, 550), Op::U8XorSplit7(534, 551), Op::Add(554, 557), Op::Add(556, 559), Op::Add(558, 561), Op::Add(560, 555), Op::UnconstrainedU32Add3(vec![349, 350, 351, 352], vec![190, 191, 192, 193], vec![121, 122, 123, 124]), Op::U8RangeCheck(566, 567), Op::U8RangeCheck(568, 569), Op::Sub(570, 134), Op::Sub(570, 136), Op::Mul(571, 572), Op::Mul(570, 573), Op::AssertEq(vec![574], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(297, 566), Op::U8Xor(298, 567), Op::U8Xor(299, 568), Op::U8Xor(296, 569), Op::UnconstrainedU32Add(vec![238, 239, 240, 241], vec![577, 578, 575, 576]), Op::U8RangeCheck(579, 580), Op::U8RangeCheck(581, 582), Op::Mul(583, 583), Op::AssertEq(vec![584], vec![583], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit4(190, 579), Op::U8XorSplit4(191, 580), Op::U8XorSplit4(192, 581), Op::U8XorSplit4(193, 582), Op::Add(587, 590), Op::Add(589, 592), Op::Add(591, 586), Op::Add(585, 588), Op::UnconstrainedU32Add3(vec![566, 567, 568, 569], vec![593, 594, 595, 596], vec![125, 126, 127, 128]), Op::U8RangeCheck(597, 598), Op::U8RangeCheck(599, 600), Op::Sub(601, 134), Op::Sub(601, 136), Op::Mul(602, 603), Op::Mul(601, 604), Op::AssertEq(vec![605], vec![140], Some("u32_add3: carry is not in {0, 1, 2}".into())), Op::U8Xor(577, 597), Op::U8Xor(578, 598), Op::U8Xor(575, 599), Op::U8Xor(576, 600), Op::UnconstrainedU32Add(vec![579, 580, 581, 582], vec![607, 608, 609, 606]), Op::U8RangeCheck(610, 611), Op::U8RangeCheck(612, 613), Op::Mul(614, 614), Op::AssertEq(vec![615], vec![614], Some("u32_add: carry is not boolean".into())), Op::U8XorSplit7(593, 610), Op::U8XorSplit7(594, 611), Op::U8XorSplit7(595, 612), Op::U8XorSplit7(596, 613), Op::Add(616, 619), Op::Add(618, 621), Op::Add(620, 623), Op::Add(622, 617), Op::Add(0, 134), Op::Call(17, vec![628, 411, 412, 413, 414, 473, 474, 475, 476, 535, 536, 537, 538, 597, 598, 599, 600, 624, 625, 626, 627, 438, 439, 440, 441, 500, 501, 502, 503, 562, 563, 564, 565, 548, 549, 550, 551, 610, 611, 612, 613, 424, 425, 426, 427, 486, 487, 488, 489, 483, 484, 485, 482, 545, 546, 547, 544, 607, 608, 609, 606, 421, 422, 423, 420, 73, 74, 75, 76, 89, 90, 91, 92, 77, 78, 79, 80, 105, 106, 107, 108, 93, 94, 95, 96, 65, 66, 67, 68, 81, 82, 83, 84, 117, 118, 119, 120, 69, 70, 71, 72, 109, 110, 111, 112, 113, 114, 115, 116, 85, 86, 87, 88, 101, 102, 103, 104, 121, 122, 123, 124, 125, 126, 127, 128, 97, 98, 99, 100], 32, false)], ctrl: Ctrl::Return(1, vec![629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660]) }))) }, layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_18() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![3]) })), 1, 1, 0, Box::new(Block { ops: vec![Op::Add(3, 2)], ctrl: Ctrl::Yield(2, vec![4]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(3, vec![3]) })), 1, 2, 0, Box::new(Block { ops: vec![Op::IORead(1, 3, 1)], ctrl: Ctrl::Return(4, vec![4]) })) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 5, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_19() -> Function { + Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_20() -> Function { + Function { body: Block { ops: vec![Op::UnconstrainedU32Add(vec![0, 1, 2, 3], vec![4, 5, 6, 7]), Op::UnconstrainedU32Add3(vec![0, 1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]), Op::Mul(16, 21)], ctrl: Ctrl::Return(0, vec![16, 21, 22]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 10, lookups: 1 }, entry: true, constrained: true } +} + +#[inline(never)] +fn expected_function_21() -> Function { + Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(16, 1), Op::Add(0, 17), Op::Mul(16, 9), Op::Add(8, 19), Op::Mul(16, 3), Op::Add(2, 21), Op::Mul(16, 11), Op::Add(10, 23), Op::Mul(16, 5), Op::Add(4, 25), Op::Mul(16, 13), Op::Add(12, 27), Op::Mul(16, 7), Op::Add(6, 29), Op::Mul(16, 15), Op::Add(14, 31), Op::Mul(18, 20), Op::UnconstrainedGToBytes(33), Op::U8RangeCheck(34, 35), Op::U8RangeCheck(36, 37), Op::Const(G::from_u64(0)), Op::U8RangeCheck(38, 42), Op::Mul(16, 35), Op::Const(G::from_u64(65536)), Op::Mul(16, 37), Op::Mul(44, 38), Op::Add(45, 46), Op::Add(36, 47), Op::Mul(44, 48), Op::Add(43, 49), Op::Add(34, 50), Op::AssertEq(vec![33], vec![51], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 24), Op::Mul(22, 20), Op::Add(53, 48), Op::Add(52, 54), Op::UnconstrainedGToBytes(55), Op::U8RangeCheck(56, 57), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 42), Op::Mul(16, 57), Op::Mul(16, 59), Op::Mul(44, 60), Op::Add(65, 66), Op::Add(58, 67), Op::Mul(44, 68), Op::Add(64, 69), Op::Add(56, 70), Op::AssertEq(vec![55], vec![71], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 28), Op::Mul(22, 24), Op::Mul(26, 20), Op::Add(74, 68), Op::Add(73, 75), Op::Add(72, 76), Op::UnconstrainedGToBytes(77), Op::U8RangeCheck(78, 79), Op::U8RangeCheck(80, 81), Op::U8RangeCheck(82, 42), Op::Mul(16, 79), Op::Mul(16, 81), Op::Mul(44, 82), Op::Add(87, 88), Op::Add(80, 89), Op::Mul(44, 90), Op::Add(86, 91), Op::Add(78, 92), Op::AssertEq(vec![77], vec![93], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 32), Op::Mul(22, 28), Op::Mul(26, 24), Op::Mul(30, 20), Op::Add(97, 90), Op::Add(96, 98), Op::Add(95, 99), Op::Add(94, 100), Op::UnconstrainedGToBytes(101), Op::U8RangeCheck(102, 103), Op::U8RangeCheck(104, 105), Op::U8RangeCheck(106, 42), Op::Mul(16, 103), Op::Mul(16, 105), Op::Mul(44, 106), Op::Add(111, 112), Op::Add(104, 113), Op::Mul(44, 114), Op::Add(110, 115), Op::Add(102, 116), Op::AssertEq(vec![101], vec![117], Some("u64_mul: column hint does not recompose".into())), Op::Mul(22, 32), Op::Mul(26, 28), Op::Mul(30, 24), Op::Add(120, 114), Op::Add(119, 121), Op::Add(118, 122), Op::UnconstrainedGToBytes(123), Op::U8RangeCheck(124, 125), Op::U8RangeCheck(126, 127), Op::U8RangeCheck(128, 42), Op::Mul(16, 125), Op::Mul(16, 127), Op::Mul(44, 128), Op::Add(133, 134), Op::Add(126, 135), Op::Mul(44, 136), Op::Add(132, 137), Op::Add(124, 138), Op::AssertEq(vec![123], vec![139], Some("u64_mul: column hint does not recompose".into())), Op::Mul(26, 32), Op::Mul(30, 28), Op::Add(141, 136), Op::Add(140, 142), Op::UnconstrainedGToBytes(143), Op::U8RangeCheck(144, 145), Op::U8RangeCheck(146, 147), Op::U8RangeCheck(148, 42), Op::Mul(16, 145), Op::Mul(16, 147), Op::Mul(44, 148), Op::Add(153, 154), Op::Add(146, 155), Op::Mul(44, 156), Op::Add(152, 157), Op::Add(144, 158), Op::AssertEq(vec![143], vec![159], Some("u64_mul: column hint does not recompose".into())), Op::Mul(30, 32), Op::Add(160, 156), Op::UnconstrainedGToBytes(161), Op::U8RangeCheck(162, 163), Op::U8RangeCheck(164, 165), Op::U8RangeCheck(166, 42), Op::Mul(16, 163), Op::Mul(16, 165), Op::Mul(44, 166), Op::Add(171, 172), Op::Add(164, 173), Op::Mul(44, 174), Op::Add(170, 175), Op::Add(162, 176), Op::AssertEq(vec![161], vec![177], Some("u64_mul: column hint does not recompose".into())), Op::AssertEq(vec![166], vec![42], Some("u64_mul: final carry exceeds one radix digit".into()))], ctrl: Ctrl::Return(0, vec![34, 35, 56, 57, 78, 79, 102, 103, 124, 125, 144, 145, 162, 163, 164, 165]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, entry: true, constrained: true } +} + +fn expected_program() -> Toplevel { + Toplevel { functions: vec![expected_function_0(), expected_function_1(), expected_function_2(), expected_function_3(), expected_function_4(), expected_function_5(), expected_function_6(), expected_function_7(), expected_function_8(), expected_function_9(), expected_function_10(), expected_function_11(), expected_function_12(), expected_function_13(), expected_function_14(), expected_function_15(), expected_function_16(), expected_function_17(), expected_function_18(), expected_function_19(), expected_function_20(), expected_function_21()], memory_sizes: vec![0, 1, 2, 10], circuits: vec![Circuit { members: vec![0, 3, 12], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 15, lookups: 2 } }, Circuit { members: vec![1], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 24, lookups: 14 } }, Circuit { members: vec![2], layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 16, lookups: 7 } }, Circuit { members: vec![4], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![5], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![6], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![7], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 1 } }, Circuit { members: vec![8], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![9], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![10], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 1 } }, Circuit { members: vec![11], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 13, lookups: 2 } }, Circuit { members: vec![14], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![15], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 3 } }, Circuit { members: vec![16], layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![17], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![18], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 5, lookups: 1 } }, Circuit { members: vec![19], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![20], layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 10, lookups: 1 } }, Circuit { members: vec![21], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 } }] } +} +pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [213, 235, 108, 220, 115, 159, 51, 229, 206, 4, 193, 234, 222, 143, 95, 162, 130, 93, 210, 36, 144, 208, 151, 97, 95, 24, 25, 23, 225, 30, 236, 67], complete: true, expected: expected_program, functions: &[ +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 1 }, output_size: 0, seed_words: 3, schema: &SCHEMA_0, pack: |context, seed| { pack_0(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_0_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_0(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 24, lookups: 14 }, output_size: 0, seed_words: 3, schema: &SCHEMA_1, pack: |context, seed| { pack_1(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_1_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_1(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 16, lookups: 7 }, output_size: 5, seed_words: 13, schema: &SCHEMA_2, pack: |context, seed| { pack_2(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_2_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_2(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 2 }, output_size: 1, seed_words: 3, schema: &SCHEMA_3, pack: |context, seed| { pack_3(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_3_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_3(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 6, schema: &SCHEMA_4, pack: pack_4, pack_typed: pack_4_typed, write: |seed, offsets, row| { write_4(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 1, seed_words: 2, schema: &SCHEMA_5, pack: |context, seed| { pack_5(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_5_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_5(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 }, output_size: 1, seed_words: 3, schema: &SCHEMA_6, pack: pack_6, pack_typed: pack_6_typed, write: |seed, offsets, row| { write_6(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 1 }, output_size: 2, seed_words: 7, schema: &SCHEMA_7, pack: pack_7, pack_typed: pack_7_typed, write: |seed, offsets, row| { write_7(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 4, lookups: 2 }, output_size: 0, seed_words: 3, schema: &SCHEMA_8, pack: pack_8, pack_typed: pack_8_typed, write: |seed, offsets, row| { write_8(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 4, lookups: 2 }, output_size: 0, seed_words: 3, schema: &SCHEMA_9, pack: pack_9, pack_typed: pack_9_typed, write: |seed, offsets, row| { write_9(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 1 }, output_size: 1, seed_words: 6, schema: &SCHEMA_10, pack: pack_10, pack_typed: pack_10_typed, write: |seed, offsets, row| { write_10(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 13, lookups: 2 }, output_size: 2, seed_words: 15, schema: &SCHEMA_11, pack: pack_11, pack_typed: pack_11_typed, write: |seed, offsets, row| { write_11(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 0, seed_words: 1, schema: &SCHEMA_12, pack: |context, seed| { pack_12(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_12_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_12(seed, offsets, row); Ok(()) } }), +None, +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 1 }, output_size: 1, seed_words: 3, schema: &SCHEMA_14, pack: pack_14, pack_typed: pack_14_typed, write: |seed, offsets, row| { write_14(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 3 }, output_size: 0, seed_words: 2, schema: &SCHEMA_15, pack: |context, seed| { pack_15(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_15_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_15(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 0, seed_words: 1, schema: &SCHEMA_16, pack: |context, seed| { pack_16(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_16_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_16(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_17, pack: pack_17, pack_typed: pack_17_typed, write: |seed, offsets, row| { write_17(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 5, lookups: 1 }, output_size: 1, seed_words: 5, schema: &SCHEMA_18, pack: pack_18, pack_typed: pack_18_typed, write: |seed, offsets, row| { write_18(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }, output_size: 0, seed_words: 2, schema: &SCHEMA_19, pack: |context, seed| { pack_19(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_19_typed(context, seed); Ok(()) }, write: write_19 }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 10, lookups: 1 }, output_size: 3, seed_words: 13, schema: &SCHEMA_20, pack: |context, seed| { pack_20(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_20_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_20(seed, offsets, row); Ok(()) } }), +Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, output_size: 16, seed_words: 17, schema: &SCHEMA_21, pack: |context, seed| { pack_21(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_21_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_21(seed, offsets, row); Ok(()) } }) +] }; diff --git a/crates/aiur/src/trace_codegen/tests/generated_cuda.rs b/crates/aiur/src/trace_codegen/tests/generated_cuda.rs new file mode 100644 index 000000000..3e1a122c5 --- /dev/null +++ b/crates/aiur/src/trace_codegen/tests/generated_cuda.rs @@ -0,0 +1,51 @@ +// Generated by Aiur.TraceCuda; regenerate from Aiur bytecode. +use crate::trace_codegen::cuda::CudaLibrary; +unsafe extern "C" { + fn aiur_trace_fixtures_contract() -> *const u8; + fn aiur_trace_fixtures_schema() -> *const u8; + pub(super) fn aiur_trace_fixtures_0(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_1(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_2(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_3(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_4(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_5(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_6(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_7(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_8(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_9(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_10(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_11(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_12(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_14(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_15(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_16(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_17(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_18(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_19(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_20(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; + pub(super) fn aiur_trace_fixtures_21(device: i32, seeds: *const u8, encoding: u32, real: usize, rows: usize, width: usize, selectors: usize, auxiliaries: usize, output: *mut u64) -> i32; +} +pub static CUDA: CudaLibrary = unsafe { CudaLibrary::new([213, 235, 108, 220, 115, 159, 51, 229, 206, 4, 193, 234, 222, 143, 95, 162, 130, 93, 210, 36, 144, 208, 151, 97, 95, 24, 25, 23, 225, 30, 236, 67], aiur_trace_fixtures_contract, aiur_trace_fixtures_schema, &[ +Some(aiur_trace_fixtures_0), +Some(aiur_trace_fixtures_1), +Some(aiur_trace_fixtures_2), +Some(aiur_trace_fixtures_3), +Some(aiur_trace_fixtures_4), +Some(aiur_trace_fixtures_5), +Some(aiur_trace_fixtures_6), +Some(aiur_trace_fixtures_7), +Some(aiur_trace_fixtures_8), +Some(aiur_trace_fixtures_9), +Some(aiur_trace_fixtures_10), +Some(aiur_trace_fixtures_11), +Some(aiur_trace_fixtures_12), +None, +Some(aiur_trace_fixtures_14), +Some(aiur_trace_fixtures_15), +Some(aiur_trace_fixtures_16), +Some(aiur_trace_fixtures_17), +Some(aiur_trace_fixtures_18), +Some(aiur_trace_fixtures_19), +Some(aiur_trace_fixtures_20), +Some(aiur_trace_fixtures_21) +], &[3, 3, 13, 3, 6, 2, 3, 7, 3, 3, 6, 15, 1, 0, 3, 2, 1, 162, 5, 2, 13, 17], &[24, 16, 24, 24, 40, 16, 24, 48, 24, 24, 48, 112, 8, 0, 24, 16, 8, 176, 40, 16, 24, 136]) }; diff --git a/crates/ffi/Cargo.toml b/crates/ffi/Cargo.toml index 7a0bc7896..28bd56b5d 100644 --- a/crates/ffi/Cargo.toml +++ b/crates/ffi/Cargo.toml @@ -49,6 +49,7 @@ serde = { version = "1.0.219", features = ["derive"], optional = true } default = [] parallel = ["aiur/parallel"] cuda = ["aiur/cuda"] +cuda-trace-codegen = ["cuda", "aiur/cuda-trace-codegen"] test-ffi = [] net = ["bytes", "tokio", "iroh", "iroh-base", "n0-error", "getrandom", "bincode", "serde"] diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs index 523fb0942..5011fd5c1 100644 --- a/crates/ffi/src/aiur/aggregate.rs +++ b/crates/ffi/src/aiur/aggregate.rs @@ -17,7 +17,7 @@ use ix_kernel::shard::ShardManifest; use ixvm_codegen::env_handle::EnvHandle; use plan::{ FoldPolicy, PlanIdentity, PlanOp, SlotSpec, build_specs, - build_statement_specs, plan_replay, + build_statement_specs, plan_replay, subtree_plan, }; use prepare::{PreparedShard, prepare_run, validate_root_statement}; use protocol::{ChildKind, allowed_blob, inner_claim}; @@ -35,6 +35,7 @@ pub(crate) use store::write_store; use store::{load_input_proofs, persist_wrapper, wrapper_address}; mod ffi; +pub mod lanes; mod plan; mod prepare; mod protocol; diff --git a/crates/ffi/src/aiur/aggregate/ffi.rs b/crates/ffi/src/aiur/aggregate/ffi.rs index 114418d26..0459d7803 100644 --- a/crates/ffi/src/aiur/aggregate/ffi.rs +++ b/crates/ffi/src/aiur/aggregate/ffi.rs @@ -13,7 +13,10 @@ use lean_ffi::object::{ LeanOwned, LeanProd, }; -use super::{RunConfig, expected_from_manifest, panic_text, run}; +use super::{ + PlanOp, RunConfig, build_statement_specs, expected_from_manifest, panic_text, + prepare_run, run, subtree_plan, +}; use crate::lean::LeanAiurAggregateExpected; use aiur::execute::IOBuffer; use ix_kernel::shard::ShardManifest; @@ -58,6 +61,86 @@ extern "C" fn rs_aiur_aggregate_expected( } } +/// `AiurSystem.aggregateSubtreePlan`: the plan cut into `subtrees` for +/// `ix prove --lanes`. Rows in post-order: `[0, slot, ids…]` for a subtree +/// (its root slot, then the manifest ids of the shards under it, sorted; +/// one id when the subtree is a raw leaf) and `[1, slot, left, right]` for +/// each join above the frontier, the root last. A tree too small to cut +/// into `subtrees` simply yields fewer. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_aggregate_subtree_plan( + env_handle: LeanExternal>, + manifest_path: LeanString>, + structural_above: LeanNat>, + subtree_size: LeanNat>, +) -> LeanExcept { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let subtree_size = lean_unbox_nat_as_usize(subtree_size.inner()); + if subtree_size == 0 { + return Err("the subtree size must be at least one leaf".to_string()); + } + let manifest_bytes = + fs::read(Path::new(manifest_path.as_str())).map_err(|error| { + format!("read manifest {}: {error}", manifest_path.as_str()) + })?; + let manifest = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|error| format!("manifest parse failed: {error}"))?; + let prepared = prepare_run(&env_handle.get().env, &manifest)?; + let specs = build_statement_specs( + &prepared, + lean_unbox_nat_as_usize(structural_above.inner()), + )?; + let ops: Vec = specs.iter().map(|spec| spec.op).collect(); + let (frontier, upper) = subtree_plan(&ops, subtree_size); + let mut rows: Vec> = + Vec::with_capacity(frontier.len() + upper.len()); + for &slot in &frontier { + let mut ids = Vec::new(); + let mut stack = vec![slot]; + while let Some(index) = stack.pop() { + match ops[index] { + PlanOp::Leaf(shard) => { + ids.push(prepared.shards[shard].original_id as usize); + }, + PlanOp::Join(left, right) => { + stack.push(left); + stack.push(right); + }, + } + } + ids.sort_unstable(); + let mut row = vec![0, slot]; + row.extend(ids); + rows.push(row); + } + for &slot in &upper { + let PlanOp::Join(left, right) = ops[slot] else { + unreachable!("upper nodes are joins") + }; + rows.push(vec![1, slot, left, right]); + } + Ok(rows) + })); + match result { + Ok(Ok(rows)) => { + let outer = LeanArray::alloc(rows.len()); + for (at, row) in rows.iter().enumerate() { + let inner = LeanArray::alloc(row.len()); + for (index, value) in row.iter().enumerate() { + inner.set(index, LeanOwned::box_usize(*value)); + } + outer.set(at, inner); + } + LeanExcept::ok(outer) + }, + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => LeanExcept::error_string(&format!( + "native subtree planning panicked: {}", + panic_text(&payload) + )), + } +} + /// Production FFI called once after Lean has compiled the IxVM and ixAggr /// systems. Proof addresses are newline-separated to keep the ABI flat. #[unsafe(no_mangle)] diff --git a/crates/ffi/src/aiur/aggregate/lanes.rs b/crates/ffi/src/aiur/aggregate/lanes.rs new file mode 100644 index 000000000..936f2af18 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes.rs @@ -0,0 +1,1265 @@ +//! Shared CPU preparation feeding one resident prover per GPU. +//! +//! Claims and ready joins execute through one bounded queue. Prepared +//! records go to the next available GPU, with joins taking priority. +//! Record reservations follow their storage through both proving rounds. +//! Under memory pressure executions wait for capacity; mutual blocking +//! cancels the youngest waiter so the selected execution can finish. + +mod checkpoint; +mod limits; +mod queue; +use limits::{HostBudget, cgroup_memory_limit}; +use queue::WorkQueue; + +use std::collections::{BTreeSet, VecDeque}; +use std::sync::mpsc; +use std::time::Instant; + +use aiur::execute::bind_record_reservation; +use aiur::record_pool::{ + PoolStats, ProverBudget, RecordPool, RecordReservation, +}; +use aiur::synthesis::ShardRetention as Retention; +use ixvm_codegen::aiur_ixvm_runner::execute_ixvm; +use ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness; + +use super::prepare::PreparedRun; +use super::protocol::serialize_claims; +use super::prove::{ + PrepareFailure, Slot, StagedSlot, finish_slot, prepare_slot, +}; +use super::store::{decode_wrapper, load_cached, read_store}; +use super::*; +use crate::aiur::lean_unbox_nat_as_usize; +use aiur::synthesis::{GatedProve, PreparedProve}; +use ix_common::address::Address; +use ixon::{Claim, Proof as IxonProof}; +use lean_ffi::object::{ + LeanBorrowed, LeanByteArray, LeanExcept, LeanExternal, LeanNat, LeanOwned, + LeanString, +}; +use rustc_hash::FxHashSet; +use std::thread; + +pub struct Config { + pub lanes: usize, + /// Per-GPU host budget in bytes, multiplied by `lanes`; 0 detects one + /// process-wide allowance. + pub max_ram_bytes: usize, + /// Preparation threads per GPU, combined into one process-wide pool. + pub exec_jobs: usize, + pub structural_above: usize, + pub cache_fri_bytes: Vec, + pub out_manifest: Option, +} + +/// The default ceiling on one execution record's counted bytes: large +/// enough that any single constant of the environments proven so far +/// executes as one claim, small enough that one record cannot take most +/// of a four-lane pool. A claim over it is bisected rather than executed. +/// `AIUR_RECORD_MAX_BYTES` overrides it. +const DEFAULT_RECORD_MAX_BYTES: usize = 128 << 30; + +enum PassOutcome { + Complete { root: String, unproven: usize }, + Refine(Vec), +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Work { + Claim(usize), + Join(usize), + Root, +} + +struct Prep { + work: Work, + children: Vec>, + reservation: RecordReservation, +} + +/// A prepared host record consumed by whichever GPU becomes available. +enum Item { + Claim { + shard: usize, + claim: Claim, + claim_bytes: Vec, + prepared: Box, + }, + Join { + slot: usize, + staged: Box, + }, + Root { + slot: usize, + staged: Box, + }, +} + +impl Item { + fn work(&self) -> Work { + match self { + Self::Claim { shard, .. } => Work::Claim(*shard), + Self::Join { slot, .. } => Work::Join(*slot), + Self::Root { .. } => Work::Root, + } + } +} + +enum Event { + ExecutionStarted { executor: usize, work: Work }, + Prepared { executor: usize, work: Work, record_bytes: usize, secs: f64 }, + PrepAvailable, + PrepFailed { executor: usize, work: Work, failure: PrepareFailure }, + Proving { worker: usize, work: Work }, + Proven { worker: usize, work: Work, result: Result, String> }, + RootProven { worker: usize, result: Result }, +} + +struct ShutdownRun<'a> { + pool: &'a RecordPool, + prep: &'a WorkQueue, + items: &'a WorkQueue, +} + +impl Drop for ShutdownRun<'_> { + fn drop(&mut self) { + self.pool.shutdown(); + self.prep.close(); + self.items.close(); + } +} + +/// The shard-proof index entry of a claim, written like Stage 1 writes it. +fn index_claim( + index_dir: &Path, + claim_bytes: &[u8], + address: &Address, +) -> Result<(), String> { + fs::create_dir_all(index_dir) + .map_err(|error| format!("create {}: {error}", index_dir.display()))?; + let digest = Address::hash(claim_bytes); + let temporary = + index_dir.join(format!("{}.tmp.{}", digest.hex(), std::process::id())); + fs::write(&temporary, format!("{}\n", address.hex())) + .and_then(|()| fs::rename(&temporary, index_dir.join(digest.hex()))) + .map_err(|error| format!("shard-proof index: {error}")) +} + +/// A claim's proof from the shard-proof index, verified natively against +/// the claim this run expects, as a raw leaf slot; `None` when absent or +/// not acceptable, never an error. +fn resume_leaf( + ctx: ProveContext<'_>, + index_dir: &Path, + slot_index: usize, + shard: usize, +) -> Option { + let spec = &ctx.specs[slot_index]; + let statement = &ctx.prepared[shard].statement; + let digest = Address::hash(&statement.claim_bytes); + let raw = fs::read_to_string(index_dir.join(digest.hex())).ok()?; + let address = Address::from_hex(raw.trim())?; + let bytes = read_store(ctx.store_dir, &address).ok()?; + if Address::hash(&bytes) != address { + return None; + } + let wrapper = decode_wrapper(&bytes).ok()?; + if wrapper.claim != statement.claim { + return None; + } + let proof = AiurProof::from_bytes(&wrapper.proof).ok()?; + let inner = inner_claim(ctx.verify_idx, &statement.claim_bytes); + ctx.ixvm_system.verify(&inner, &proof).ok()?; + Some(Slot { + kind: ChildKind::Ixvm, + statement: spec.statement.clone(), + outer_claim: inner.clone(), + proof, + proof_address: Some(address), + claims_bytes: serialize_claims(&[&inner]), + }) +} + +fn prepare_loop( + ctx: ProveContext<'_>, + executor: usize, + env: &ixon::Env, + owned: &[Vec
], + max_ram_bytes: Option, + prep: &WorkQueue, + items: &WorkQueue, + events: &mpsc::Sender, +) { + while let Some(task) = prep.pop() { + let Prep { work, children, reservation } = task; + let began = Instant::now(); + let _ = events.send(Event::ExecutionStarted { executor, work }); + let binding = bind_record_reservation(&reservation); + let outcome = (|| -> Result { + match work { + Work::Claim(shard) => { + let (claim, input, mut io) = + build_shard_check_env_witness(env, &owned[shard]) + .map_err(|e| format!("witness build: {e}"))?; + let prepared = match ctx.ixvm_system.prepare_ixvm_within_budget( + ctx.verify_idx, &input, &mut io, execute_ixvm, + max_ram_bytes, true, Some(Retention::Regenerate), + ) { + Ok(prepared) => prepared, + Err(GatedProve::Failed(aiur::execute::ExecError::RecordBudgetExceeded { bytes, cap })) => { + return Err(PrepareFailure::OverRecordCap { bytes, cap }); + }, + Err(GatedProve::Failed(aiur::execute::ExecError::RecordMemoryContention)) => { + return Err(PrepareFailure::MemoryContention); + }, + Err(GatedProve::Failed(error)) => return Err(format!("execution failed: {error}").into()), + Err(GatedProve::Split { peak, .. }) => return Err(format!( + "no trace-shard count fits the process budget (whole-execution peak {peak} B)" + ).into()), + Err(_) => return Err("execution did not prepare a proof".into()), + }; + let mut claim_bytes = Vec::new(); + claim.put(&mut claim_bytes); + Ok(Item::Claim { + shard, + claim, + claim_bytes, + prepared: Box::new(prepared), + }) + }, + Work::Join(slot) => { + let staged = prepare_slot(ctx, slot, &children)?; + Ok(Item::Join { slot, staged: Box::new(staged) }) + }, + Work::Root => { + let slot = ctx.specs.len() - 1; + let staged = prepare_slot(ctx, slot, &children)?; + Ok(Item::Root { slot, staged: Box::new(staged) }) + }, + } + })(); + reservation.finish_execution(); + let measured = reservation.bytes(); + drop(binding); + drop(reservation); + match outcome { + Ok(item) => { + // Publish preparation before handing ownership to a prover. + let _ = events.send(Event::Prepared { + executor, + work, + record_bytes: measured, + secs: began.elapsed().as_secs_f64(), + }); + if items.push(item, !matches!(work, Work::Claim(_))).is_err() { + return; + } + // A producer waiting on a full prepared queue still occupies its + // execution slot and retains the record's memory charge. + let _ = events.send(Event::PrepAvailable); + }, + Err(failure) => { + let _ = events.send(Event::PrepFailed { executor, work, failure }); + }, + } + } +} + +/// Each job's proving rounds stay on this device; completed proofs +/// release records and make dependent joins ready. +fn prove_loop( + ctx: ProveContext<'_>, + worker: usize, + prepared_run: &PreparedRun, + leaf_slot: &[usize], + index_dir: &Path, + items: &WorkQueue, + pool: &RecordPool, + events: &mpsc::Sender, +) { + while let Some(item) = items.pop() { + let _ = events.send(Event::Proving { worker, work: item.work() }); + match item { + Item::Claim { shard, claim, claim_bytes, prepared } => { + let result = (|| -> Result, String> { + let (_, proof, _) = ctx.ixvm_system.prove_prepared(*prepared); + let proof_bytes = proof + .to_bytes() + .map_err(|e| format!("proof serialization: {e}"))?; + let wrapper = IxonProof::new(claim, proof_bytes); + let mut wrapper_bytes = Vec::new(); + wrapper.put(&mut wrapper_bytes); + write_store(ctx.store_dir, &claim_bytes)?; + let address = write_store(ctx.store_dir, &wrapper_bytes)?; + index_claim(index_dir, &claim_bytes, &address)?; + let inner = inner_claim(ctx.verify_idx, &claim_bytes); + Ok(Arc::new(Slot { + kind: ChildKind::Ixvm, + statement: ctx.specs[leaf_slot[shard]].statement.clone(), + outer_claim: inner.clone(), + proof, + proof_address: Some(address), + claims_bytes: serialize_claims(&[&inner]), + })) + })(); + let _ = events.send(Event::Proven { + worker, + work: Work::Claim(shard), + result, + }); + }, + Item::Join { slot, staged } => { + let result = finish_slot(ctx, slot, *staged); + let _ = + events.send(Event::Proven { worker, work: Work::Join(slot), result }); + }, + Item::Root { slot, staged } => { + let result = (|| -> Result { + let root = finish_slot(ctx, slot, *staged)?; + validate_root_statement(prepared_run, &root.statement)?; + // Wrap until the final proof is a single trace shard. + let mut wrapped: Option = None; + loop { + let current = wrapped.as_ref().unwrap_or(&root.proof); + let shards = current.preamble.headers.len(); + if shards <= 1 { + break; + } + let reservation = pool + .try_admit() + .map_err(|error| format!("root wrap admission: {error:?}"))? + .ok_or("root wrap cannot acquire record capacity")?; + let binding = bind_record_reservation(&reservation); + let next = wrap_root(ctx, &root, current)?; + drop(binding); + drop(reservation); + if next.preamble.headers.len() >= shards { + break; + } + wrapped = Some(next); + } + let proof = wrapped.as_ref().unwrap_or(&root.proof); + ctx.aggr_system.verify(&root.outer_claim, proof).map_err( + |error| { + format!("aggregate root proof failed verification: {error:?}") + }, + )?; + let address = match (&wrapped, &root.proof_address) { + (None, Some(address)) => address.clone(), + _ => persist_wrapper(ctx.store_dir, &root.statement, proof)?, + }; + Ok(address.hex()) + })(); + let _ = events.send(Event::RootProven { worker, result }); + }, + } + } +} + +/// The whole run. Prints progress on stderr and returns the verified +/// root address. +/// The composed verdict: every claim proof the run holds, proved or +/// reused, verified natively against its claim, in parallel. Returns the +/// failures and the number of claims without a proof to verify: claims +/// retired under a cached join whose proof the index no longer holds, +/// which rest on that join's own native verification when it was loaded. +fn composed_verdict( + ixvm: &AiurSystem, + verify_idx: usize, + prepared: &PreparedRun, + leaves: &[Option>], +) -> (Vec, usize) { + let failures = leaves + .par_iter() + .enumerate() + .filter_map(|(shard, slot)| { + let slot = slot.as_ref()?; + let inner = + inner_claim(verify_idx, &prepared.shards[shard].statement.claim_bytes); + ixvm.verify(&inner, &slot.proof).err().map(|error| { + format!( + "claim {}: proof fails verification: {error:?}", + prepared.shards[shard].original_id + ) + }) + }) + .collect(); + (failures, leaves.iter().filter(|slot| slot.is_none()).count()) +} + +pub fn run( + cfg: &Config, + ixvm: &AiurSystem, + aggr: &AiurSystem, + env: &ixon::Env, + manifest_path: &Path, + verify_idx: usize, + aggr_idx: usize, +) -> Result { + if cfg.cache_fri_bytes.len() != 40 { + return Err("aggregate cache FRI serialization must be 40 bytes".into()); + } + let started = Instant::now(); + let manifest_bytes = fs::read(manifest_path).map_err(|error| { + format!("read manifest {}: {error}", manifest_path.display()) + })?; + let source = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|error| format!("manifest parse failed: {error}"))?; + let home = std::env::var_os("HOME").ok_or("no HOME environment variable")?; + let cache_root = std::env::var_os("AIUR_LANES_CACHE_DIR") + .map_or_else(|| PathBuf::from(home).join(".ix/cache"), PathBuf::from); + let checkpoint_path = cache_root + .join("refined-manifests") + .join(format!("{}.ixes", Address::hash(&manifest_bytes).hex())); + let mut manifest = match fs::read(&checkpoint_path) { + Ok(bytes) => { + let refined = ShardManifest::from_bytes(&bytes).map_err(|error| { + format!("refined manifest {}: {error}", checkpoint_path.display()) + })?; + say(&format!( + "resuming refined partition with {} claims from {}", + refined.num_shards, + checkpoint_path.display() + )); + refined + }, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => source, + Err(error) => { + return Err(format!("read {}: {error}", checkpoint_path.display())); + }, + }; + let record_max_bytes = match std::env::var("AIUR_RECORD_MAX_BYTES") { + Ok(value) => value + .parse::() + .ok() + .filter(|&n| n > 0) + .ok_or("AIUR_RECORD_MAX_BYTES must be a positive integer")?, + Err(std::env::VarError::NotPresent) => DEFAULT_RECORD_MAX_BYTES, + Err(error) => return Err(format!("AIUR_RECORD_MAX_BYTES: {error}")), + }; + let mut profile = None; + let mut pool_stats = PoolStats::default(); + loop { + match run_manifest( + cfg, + ixvm, + aggr, + env, + &manifest, + verify_idx, + aggr_idx, + &cache_root, + record_max_bytes, + started, + &mut pool_stats, + )? { + PassOutcome::Complete { root, unproven } => { + if let Some(path) = &cfg.out_manifest { + checkpoint::write_atomic(path, &manifest.to_bytes())?; + say(&format!("final partition: {}", path.display())); + } + say(&format!( + "record pool: peak granted {} GiB, {} growth waits ({:.1}s summed across executions), {} contention retries", + format_gib(pool_stats.peak_reserved), + pool_stats.waits, + pool_stats.wait_time.as_secs_f64(), + pool_stats.retries, + )); + let coverage = if unproven == 0 { + String::new() + } else { + format!( + " ({unproven} claims retired under verified cached joins have no indexed proof)" + ) + }; + say(&format!( + "root {root} verified; composed verdict OK{coverage}; end to end {}s", + started.elapsed().as_secs() + )); + return Ok(root); + }, + PassOutcome::Refine(ids) => { + let profile = profile + .get_or_insert_with(|| crate::kernel::static_block_profile(env)); + let (refined, parts) = manifest.bisect_leaves(profile, &ids)?; + checkpoint::write_atomic(&checkpoint_path, &refined.to_bytes())?; + for (&id, parts) in ids.iter().zip(parts) { + say(&format!("split claim {id} into claims {parts:?}")); + } + say(&format!( + "refined partition: {} claims, saved to {}; continuing with completed proofs", + refined.num_shards, + checkpoint_path.display() + )); + manifest = refined; + }, + } + } +} + +/// One pass over a manifest: the plan, the host budget it runs under, and +/// a resident prover pair per device. +struct Pass { + prepared: PreparedRun, + specs: Vec, + ixvm_vk: Vec, + aggr_vk: Vec, + allowed: Vec, + verify_idx: usize, + aggr_idx: usize, + root_slot: usize, + root_left: usize, + root_right: usize, + /// The plan slot holding each manifest shard's claim. + leaf_slot: Vec, + /// The sorted leaves of each shard's statement. + owned: Vec>, + store_dir: PathBuf, + cache_dir: PathBuf, + index_dir: PathBuf, + /// CPU execution threads shared by every lane. + executions: usize, + /// The process-wide host limit, the prover budget of every slot. + wrap_budget: Option, + pool: RecordPool, + systems: Vec<(AiurSystem, AiurSystem)>, +} + +impl Pass { + fn shards(&self) -> usize { + self.prepared.shards.len() + } + + /// One proving context per device, all over the same plan and keys. + fn contexts(&self) -> Vec> { + self + .systems + .iter() + .map(|(ixvm_system, aggr_system)| ProveContext { + specs: &self.specs, + prepared: &self.prepared.shards, + proofs: None, + owner_by_address: &self.prepared.owner_by_address, + ixvm_system, + aggr_system, + ixvm_vk: &self.ixvm_vk, + aggr_vk: &self.aggr_vk, + allowed: &self.allowed, + verify_idx: self.verify_idx, + aggr_idx: self.aggr_idx, + store_dir: &self.store_dir, + cache_dir: Some(&self.cache_dir), + reprove_slot: None, + write_outputs: true, + wrap_budget: self.wrap_budget, + range_width: 0, + range_jobs: 1, + }) + .collect() + } +} + +fn say(message: &str) { + eprintln!("[lanes] {message}"); +} + +fn plan_pass( + cfg: &Config, + ixvm: &AiurSystem, + aggr: &AiurSystem, + env: &ixon::Env, + manifest: &ShardManifest, + verify_idx: usize, + aggr_idx: usize, + cache_root: &Path, + record_max_bytes: usize, +) -> Result { + let prepared = prepare_run(env, manifest)?; + let ixvm_vk = aiur::vk_codec::aiur_system_to_bytes(ixvm) + .map_err(|error| format!("IxVM VK serialization failed: {error}"))?; + let aggr_vk = aiur::vk_codec::aiur_system_to_bytes(aggr) + .map_err(|error| format!("ixAggr VK serialization failed: {error}"))?; + let allowed = allowed_blob(&ixvm_vk, verify_idx, &aggr_vk, aggr_idx); + let specs = build_specs( + &prepared, + PlanIdentity { + verify_idx, + aggr_idx, + aggr_vk: &aggr_vk, + allowed: &allowed, + cache_fri_bytes: &cfg.cache_fri_bytes, + }, + FoldPolicy { structural_above: cfg.structural_above, direct_joins: true }, + )?; + let root_slot = specs.len().checked_sub(1).ok_or("empty plan")?; + let PlanOp::Join(root_left, root_right) = specs[root_slot].op else { + return Err("the manifest has one shard; there is nothing to join".into()); + }; + let mut leaf_slot = vec![usize::MAX; prepared.shards.len()]; + for (index, spec) in specs.iter().enumerate() { + if let PlanOp::Leaf(shard) = spec.op { + leaf_slot[shard] = index; + } + } + let owned: Vec> = prepared + .shards + .iter() + .map(|shard| { + let mut leaves = Vec::new(); + shard.statement.subjects.collect_leaves(&mut leaves); + leaves.sort_unstable(); + leaves + }) + .collect(); + + let home = std::env::var_os("HOME").ok_or("no HOME environment variable")?; + let ix_root = PathBuf::from(home).join(".ix"); + let store_dir = ix_root.join("store"); + let cache_dir = cache_root.join("aggregate"); + let index_dir = cache_root.join("shard-proofs"); + fs::create_dir_all(&cache_dir) + .map_err(|error| format!("create {}: {error}", cache_dir.display()))?; + + if cfg.lanes == 0 { + return Err("at least one lane is required".into()); + } + let exec_jobs = if cfg.exec_jobs == 0 { + let cores = thread::available_parallelism().map_or(1, usize::from); + (cores / cfg.lanes).max(1) + } else { + cfg.exec_jobs + }; + let executions = exec_jobs + .checked_mul(cfg.lanes) + .ok_or("execution thread count overflow")?; + let cells = match std::env::var("AIUR_TRACE_SHARD_MAX_CELLS") { + Ok(value) => value + .parse::() + .ok() + .filter(|&n| n > 0) + .ok_or("AIUR_TRACE_SHARD_MAX_CELLS must be a positive integer")?, + Err(std::env::VarError::NotPresent) => 1_500_000_000, + Err(error) => return Err(format!("AIUR_TRACE_SHARD_MAX_CELLS: {error}")), + }; + let cgroup_limit = cgroup_memory_limit(); + let host = HostBudget::new( + cfg.lanes, + executions, + cfg.max_ram_bytes, + super::super::protocol::detected_ram_budget(), + cgroup_limit, + cells, + )?; + let pool = RecordPool::for_provers( + host.records, + host.initial, + ProverBudget { trace_cells: cells, host_workspace: host.workspace }, + ) + .with_record_limit(record_max_bytes); + say(&format!( + "host budget {} GiB process-wide (requested {} GiB per GPU, visible cgroup limit {}): {} GiB shared records, {} GiB workspace per GPU, {} GiB headroom; {executions} CPU executions, {} prepared queue slots; {} GiB initial reservation, growth waits for shared capacity; {cells} trace cells", + format_gib(host.limit), + format_gib(cfg.max_ram_bytes), + cgroup_limit.map_or_else( + || "unlimited or unavailable".into(), + |bytes| format!("{} GiB", format_gib(bytes)) + ), + format_gib(host.records), + format_gib(host.workspace), + format_gib(host.headroom), + cfg.lanes, + format_gib(host.initial.min(pool.record_limit())), + )); + say(&format!( + "per-record ceiling {} GiB; oversized environment claims are bisected automatically", + format_gib(pool.record_limit()) + )); + + // A prover pair per device, sharing the bytecode of the systems the + // CLI built. The verifying keys must not depend on the device: every + // cache key and claim binding is derived from them. + say(&format!("building {} resident workers", cfg.lanes)); + let systems: Vec<(AiurSystem, AiurSystem)> = (0..cfg.lanes) + .map(|g| { + let device = + i32::try_from(g).map_err(|error| format!("lane {g}: {error}"))?; + Ok((ixvm.on_device(device), aggr.on_device(device))) + }) + .collect::>()?; + for (g, (worker_ixvm, worker_aggr)) in systems.iter().enumerate() { + let same = + aiur::vk_codec::aiur_system_to_bytes(worker_ixvm).ok().as_deref() + == Some(ixvm_vk.as_slice()) + && aiur::vk_codec::aiur_system_to_bytes(worker_aggr).ok().as_deref() + == Some(aggr_vk.as_slice()); + if !same { + return Err(format!( + "the verifying key of the prover on device {g} differs from device 0's" + )); + } + } + + Ok(Pass { + prepared, + specs, + ixvm_vk, + aggr_vk, + allowed, + verify_idx, + aggr_idx, + root_slot, + root_left, + root_right, + leaf_slot, + owned, + store_dir, + cache_dir, + index_dir, + executions, + wrap_budget: Some(host.limit), + pool, + systems, + }) +} + +/// What persisted state fills before a pass dispatches anything: cached +/// joins with the subtrees they retire, and claims the index still proves. +struct Resumed { + slots: Vec>>, + retired: Vec, + claim_done: Vec, +} + +fn resume_pass(pass: &Pass, ctx: ProveContext<'_>) -> Resumed { + let count = pass.specs.len(); + let shards = pass.shards(); + // Cached joins from the root down retire their subtrees. + let mut slots: Vec>> = vec![None; count]; + let mut retired = vec![false; count]; + for index in (0..pass.root_slot).rev() { + let spec = &pass.specs[index]; + if retired[index] || spec.kind != ChildKind::Aggr { + continue; + } + let Some((proof, address)) = + load_cached(ctx.aggr_system, ctx.store_dir, ctx.cache_dir, index, spec) + else { + continue; + }; + slots[index] = Some(Arc::new(Slot { + kind: ChildKind::Aggr, + statement: spec.statement.clone(), + outer_claim: spec.outer_claim.clone(), + proof, + proof_address: Some(address), + claims_bytes: serialize_claims(&[&spec.outer_claim]), + })); + let mut stack = match spec.op { + PlanOp::Join(l, r) => vec![l, r], + PlanOp::Leaf(_) => Vec::new(), + }; + while let Some(slot) = stack.pop() { + if retired[slot] { + continue; + } + retired[slot] = true; + if let PlanOp::Join(l, r) = pass.specs[slot].op { + stack.push(l); + stack.push(r); + } + } + } + // Indexed claim proofs stand in for their claims. A claim retired under + // a cached join is still loaded when the index holds its proof, so the + // composed verdict can verify it independently. + let mut claim_done = vec![false; shards]; + let resumed: Vec> = (0..shards) + .into_par_iter() + .map(|shard| { + resume_leaf(ctx, &pass.index_dir, pass.leaf_slot[shard], shard) + }) + .collect(); + let mut reused = 0usize; + for (shard, slot) in resumed.into_iter().enumerate() { + if let Some(slot) = slot { + slots[pass.leaf_slot[shard]] = Some(Arc::new(slot)); + claim_done[shard] = true; + reused += 1; + } else if retired[pass.leaf_slot[shard]] { + claim_done[shard] = true; + } + } + let cached_joins = slots + .iter() + .enumerate() + .filter(|(i, s)| { + s.is_some() + && *i != pass.root_slot + && !matches!(pass.specs[*i].op, PlanOp::Leaf(_)) + }) + .count(); + say(&format!( + "{shards} claims ({reused} reused from the index, {} retired under cached joins without an indexed proof), {} joins ({cached_joins} cached)", + claim_done.iter().filter(|d| **d).count() - reused, + count - shards + )); + Resumed { slots, retired, claim_done } +} + +/// The dispatch state of a running pass: which plan slots are proven, +/// queued, or executing, and how the pass ended. +struct Scheduler<'a> { + pass: &'a Pass, + manifest: &'a ShardManifest, + started: Instant, + slots: Vec>>, + retired: Vec, + claim_done: Vec, + claim_queue: VecDeque, + /// Joins queued or executing. + dispatched: FxHashSet, + root_dispatched: bool, + free_executors: usize, + in_flight: usize, + /// Claims whose records exceed the per-record ceiling, split once the + /// active work drains. + to_split: BTreeSet, + root_address: Option, + failure: Option, +} + +impl<'a> Scheduler<'a> { + fn new( + pass: &'a Pass, + manifest: &'a ShardManifest, + started: Instant, + resumed: Resumed, + ) -> Self { + let Resumed { slots, retired, claim_done } = resumed; + let claim_queue = (0..pass.shards()).filter(|&s| !claim_done[s]).collect(); + Self { + pass, + manifest, + started, + slots, + retired, + claim_done, + claim_queue, + dispatched: FxHashSet::default(), + root_dispatched: false, + free_executors: pass.executions, + in_flight: 0, + to_split: BTreeSet::new(), + root_address: None, + failure: None, + } + } + + fn work_name(&self, work: Work) -> String { + match work { + Work::Claim(shard) => { + format!("claim {}", self.pass.prepared.shards[shard].original_id) + }, + Work::Join(slot) => format!("join {slot}"), + Work::Root => "root".to_string(), + } + } + + fn elapsed(&self) -> u64 { + self.started.elapsed().as_secs() + } + + fn idle(&self) -> bool { + self.in_flight == 0 && self.free_executors == self.pass.executions + } + + fn finished(&self) -> bool { + self.failure.is_some() || self.root_address.is_some() + } + + /// The next unit an executor can take: a join whose inputs are proven, + /// then the root once every claim is done, then the oldest claim. + fn next_work(&self) -> Option { + let pass = self.pass; + let ready_join = (0..pass.root_slot).find(|&index| { + !self.retired[index] + && self.slots[index].is_none() + && !self.dispatched.contains(&index) + && match pass.specs[index].op { + PlanOp::Join(l, r) => { + self.slots[l].is_some() && self.slots[r].is_some() + }, + PlanOp::Leaf(_) => false, + } + }); + if let Some(slot) = ready_join { + Some(Work::Join(slot)) + } else if !self.root_dispatched + && self.claim_done.iter().all(|d| *d) + && self.slots[pass.root_left].is_some() + && self.slots[pass.root_right].is_some() + { + Some(Work::Root) + } else { + self.claim_queue.front().map(|&shard| Work::Claim(shard)) + } + } + + /// The proven inputs `work` joins. + fn children(&self, work: Work) -> Vec> { + let (l, r) = match work { + Work::Claim(_) => return Vec::new(), + Work::Join(slot) => { + let PlanOp::Join(l, r) = self.pass.specs[slot].op else { + unreachable!() + }; + (l, r) + }, + Work::Root => (self.pass.root_left, self.pass.root_right), + }; + vec![self.slots[l].clone().unwrap(), self.slots[r].clone().unwrap()] + } + + /// Accounts for `work` having left for an executor. + fn queued(&mut self, work: Work) { + self.free_executors -= 1; + self.in_flight += 1; + say(&format!( + "{} dispatched at +{}s", + self.work_name(work), + self.elapsed() + )); + match work { + Work::Claim(_) => { + self.claim_queue.pop_front(); + }, + Work::Join(slot) => { + self.dispatched.insert(slot); + }, + Work::Root => self.root_dispatched = true, + } + } + + /// Every claim's slot, in manifest shard order. + fn leaves(&self) -> Vec>> { + self.pass.leaf_slot.iter().map(|&slot| self.slots[slot].clone()).collect() + } + + fn handle(&mut self, event: Event) { + match event { + Event::ExecutionStarted { executor, work } => say(&format!( + "executor {executor}: {} execution started at +{}s", + self.work_name(work), + self.elapsed(), + )), + Event::Prepared { executor, work, record_bytes, secs } => say(&format!( + "executor {executor}: {} executed in {secs:.1}s, record {record_bytes} B ({} GiB) at +{}s", + self.work_name(work), + format_gib(record_bytes), + self.elapsed(), + )), + Event::PrepAvailable => { + self.free_executors += 1; + }, + Event::PrepFailed { executor, work, failure } => { + self.free_executors += 1; + self.in_flight -= 1; + self.prep_failed(executor, work, failure); + }, + Event::Proving { worker, work } => say(&format!( + "worker {worker}: {} proving started at +{}s", + self.work_name(work), + self.elapsed(), + )), + Event::Proven { worker, work, result } => { + self.in_flight -= 1; + match (work, result) { + (Work::Claim(shard), Ok(slot)) => { + self.slots[self.pass.leaf_slot[shard]] = Some(slot); + self.claim_done[shard] = true; + say(&format!( + "worker {worker}: claim {} proven at +{}s ({} left)", + self.pass.prepared.shards[shard].original_id, + self.elapsed(), + self.claim_done.iter().filter(|d| !**d).count() + )); + }, + (Work::Join(slot), Ok(proof)) => { + self.slots[slot] = Some(proof); + say(&format!( + "worker {worker}: join {slot} published at +{}s", + self.elapsed() + )); + }, + (_, Err(error)) => { + self.failure = Some(format!("{}: {error}", self.work_name(work))); + }, + (Work::Root, Ok(_)) => { + unreachable!("root reports through RootProven") + }, + } + }, + Event::RootProven { worker, result } => match result { + Ok(address) => { + say(&format!("worker {worker}: root proven at +{}s", self.elapsed())); + self.root_address = Some(address); + }, + Err(error) => self.failure = Some(format!("root: {error}")), + }, + } + } + + /// A contended execution is requeued; one over the record ceiling marks + /// its claim for splitting, and anything else ends the pass. + fn prep_failed( + &mut self, + executor: usize, + work: Work, + failure: PrepareFailure, + ) { + match failure { + PrepareFailure::MemoryContention => { + say(&format!( + "executor {executor}: {} released for memory contention; requeued", + self.work_name(work) + )); + match work { + Work::Claim(shard) => self.claim_queue.push_back(shard), + Work::Join(slot) => { + self.dispatched.remove(&slot); + }, + Work::Root => self.root_dispatched = false, + } + }, + PrepareFailure::OverRecordCap { bytes, cap } => { + let Work::Claim(shard) = work else { + self.failure = Some(format!( + "{}: aggregation record needs {bytes} B, above the {cap} B per-record ceiling; an aggregation execution cannot be split as an environment claim", + self.work_name(work) + )); + return; + }; + let id = self.pass.prepared.shards[shard].original_id; + let source = self + .manifest + .shards + .iter() + .find(|s| s.id == id) + .expect("prepared claim belongs to the manifest"); + if source.blocks.len() > 1 { + self.to_split.insert(id); + say(&format!( + "claim {id}: record needs {bytes} B, above the {cap} B per-record ceiling; draining active work before splitting this claim" + )); + } else { + self.failure = Some(format!( + "claim {id}: record needs {bytes} B, above the {cap} B per-record ceiling; its single atomic block cannot be split further" + )); + } + }, + PrepareFailure::Other(error) => { + self.failure = Some(format!("{}: {error}", self.work_name(work))); + }, + } + } +} + +fn run_manifest( + cfg: &Config, + ixvm: &AiurSystem, + aggr: &AiurSystem, + env: &ixon::Env, + manifest: &ShardManifest, + verify_idx: usize, + aggr_idx: usize, + cache_root: &Path, + record_max_bytes: usize, + started: Instant, + pool_stats: &mut PoolStats, +) -> Result { + let pass = plan_pass( + cfg, + ixvm, + aggr, + env, + manifest, + verify_idx, + aggr_idx, + cache_root, + record_max_bytes, + )?; + let contexts = pass.contexts(); + let resumed = resume_pass(&pass, contexts[0]); + + let (events_tx, events_rx) = mpsc::channel::(); + let prep_queue = WorkQueue::::new(pass.executions); + let item_queue = WorkQueue::::new(cfg.lanes); + let outcome = thread::scope(|scope| -> Result { + let _shutdown = + ShutdownRun { pool: &pass.pool, prep: &prep_queue, items: &item_queue }; + for executor in 0..pass.executions { + let events = events_tx.clone(); + let (ctx, pass, prep, items) = + (contexts[0], &pass, &prep_queue, &item_queue); + scope.spawn(move || { + prepare_loop( + ctx, + executor, + env, + &pass.owned, + pass.wrap_budget, + prep, + items, + &events, + ) + }); + } + for (worker, &ctx) in contexts.iter().enumerate() { + let events = events_tx.clone(); + let (pass, items) = (&pass, &item_queue); + scope.spawn(move || { + prove_loop( + ctx, + worker, + &pass.prepared, + &pass.leaf_slot, + &pass.index_dir, + items, + &pass.pool, + &events, + ) + }); + } + drop(events_tx); + + let mut scheduler = Scheduler::new(&pass, manifest, started, resumed); + let mut verdict: Option< + thread::ScopedJoinHandle<'_, (Vec, usize)>, + > = None; + loop { + while scheduler.free_executors > 0 && scheduler.to_split.is_empty() { + let Some(work) = scheduler.next_work() else { + break; + }; + let Some(reservation) = pass + .pool + .try_admit() + .map_err(|e| format!("record admission: {e:?}"))? + else { + break; + }; + let children = scheduler.children(work); + prep_queue + .push( + Prep { work, children, reservation }, + !matches!(work, Work::Claim(_)), + ) + .map_err(|Prep { work, .. }| { + let kind = + if matches!(work, Work::Claim(_)) { "claim" } else { "join" }; + format!("execution queue closed before a {kind} was queued") + })?; + scheduler.queued(work); + if work == Work::Root && verdict.is_none() { + let (leaves, pass) = (scheduler.leaves(), &pass); + verdict = Some(scope.spawn(move || { + composed_verdict(ixvm, verify_idx, &pass.prepared, &leaves) + })); + } + } + if scheduler.idle() { + if scheduler.to_split.is_empty() { + scheduler.failure = Some( + "scheduler stalled: nothing runs and nothing can be admitted" + .to_string(), + ); + } + break; + } + let event = + events_rx.recv().map_err(|e| format!("worker channel closed: {e}"))?; + scheduler.handle(event); + if scheduler.finished() { + break; + } + } + drop(_shutdown); + if let Some(error) = scheduler.failure { + return Err(format!( + "{error}; rerun the same command to resume from what was persisted" + )); + } + if !scheduler.to_split.is_empty() { + return Ok(PassOutcome::Refine(scheduler.to_split.into_iter().collect())); + } + let root = scheduler.root_address.ok_or("no root proof")?; + let (failures, unproven) = verdict + .ok_or("root proven before composed verdict started")? + .join() + .map_err(|payload| { + format!("composed verdict thread panicked: {}", panic_text(&payload)) + })?; + if failures.is_empty() { + Ok(PassOutcome::Complete { root, unproven }) + } else { + Err(failures.join("; ")) + } + }); + let stats = pass.pool.stats(); + pool_stats.peak_reserved = pool_stats.peak_reserved.max(stats.peak_reserved); + pool_stats.waits += stats.waits; + pool_stats.wait_time += stats.wait_time; + pool_stats.retries += stats.retries; + outcome +} + +/// `AiurSystem.proveLanes`: the whole multi-device run. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_prove_lanes( + ixvm_system: LeanExternal>, + aggr_system: LeanExternal>, + env_handle: LeanExternal>, + manifest_path: LeanString>, + verify_idx: LeanNat>, + aggr_idx: LeanNat>, + lanes: LeanNat>, + max_ram_bytes: LeanNat>, + exec_jobs: LeanNat>, + structural_above: LeanNat>, + cache_fri_bytes: LeanByteArray>, + out_manifest: LeanString>, +) -> LeanExcept { + let cfg = Config { + lanes: lean_unbox_nat_as_usize(lanes.inner()), + max_ram_bytes: lean_unbox_nat_as_usize(max_ram_bytes.inner()), + exec_jobs: lean_unbox_nat_as_usize(exec_jobs.inner()), + structural_above: lean_unbox_nat_as_usize(structural_above.inner()), + cache_fri_bytes: cache_fri_bytes.as_bytes().to_vec(), + out_manifest: (!out_manifest.as_str().is_empty()) + .then(|| PathBuf::from(out_manifest.as_str())), + }; + if cfg.lanes == 0 { + return LeanExcept::error_string("at least one lane is required"); + } + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + run( + &cfg, + ixvm_system.get(), + aggr_system.get(), + &env_handle.get().env, + Path::new(manifest_path.as_str()), + lean_unbox_nat_as_usize(verify_idx.inner()), + lean_unbox_nat_as_usize(aggr_idx.inner()), + ) + })); + match result { + Ok(Ok(root)) => LeanExcept::ok(LeanString::new(&root)), + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => LeanExcept::error_string(&format!( + "lane scheduler panicked: {}", + panic_text(&payload) + )), + } +} diff --git a/crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs b/crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs new file mode 100644 index 000000000..9b22aaf10 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes/checkpoint.rs @@ -0,0 +1,65 @@ +use std::{ + fs::{self, OpenOptions}, + io::Write, + path::Path, + sync::atomic::{AtomicU64, Ordering}, +}; + +static NEXT_TEMP: AtomicU64 = AtomicU64::new(0); + +/// A reader sees either the previous complete partition or the next one. +pub(super) fn write_atomic(path: &Path, bytes: &[u8]) -> Result<(), String> { + let parent = path + .parent() + .filter(|p| !p.as_os_str().is_empty()) + .unwrap_or_else(|| Path::new(".")); + fs::create_dir_all(parent) + .map_err(|error| format!("create {}: {error}", parent.display()))?; + let mut name = + path.file_name().ok_or("manifest path has no filename")?.to_os_string(); + name.push(format!( + ".tmp.{}.{}", + std::process::id(), + NEXT_TEMP.fetch_add(1, Ordering::Relaxed) + )); + let temporary = parent.join(name); + let mut file = OpenOptions::new() + .write(true) + .create_new(true) + .open(&temporary) + .map_err(|error| format!("create {}: {error}", temporary.display()))?; + let result = (|| -> std::io::Result<()> { + file.write_all(bytes)?; + file.sync_all()?; + fs::rename(&temporary, path)?; + Ok(()) + })(); + if result.is_err() { + let _ = fs::remove_file(&temporary); + } + result.map_err(|error| format!("write manifest {}: {error}", path.display())) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn replacement_is_complete_and_failed_writes_leave_no_temporary() { + let dir = std::env::temp_dir().join(format!( + "ix-refined-manifest-{}-{}", + std::process::id(), + NEXT_TEMP.fetch_add(1, Ordering::Relaxed) + )); + let path = dir.join("partition.ixes"); + write_atomic(&path, b"first partition").unwrap(); + write_atomic(&path, b"refined partition").unwrap(); + assert_eq!(fs::read(&path).unwrap(), b"refined partition"); + let directory_target = dir.join("directory"); + fs::create_dir(&directory_target).unwrap(); + assert!(write_atomic(&directory_target, b"invalid target").is_err()); + assert!(directory_target.is_dir()); + assert_eq!(fs::read_dir(&dir).unwrap().count(), 2); + fs::remove_dir_all(dir).unwrap(); + } +} diff --git a/crates/ffi/src/aiur/aggregate/lanes/limits.rs b/crates/ffi/src/aiur/aggregate/lanes/limits.rs new file mode 100644 index 000000000..0003e505c --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes/limits.rs @@ -0,0 +1,140 @@ +use std::{ + fs, + path::{Path, PathBuf}, +}; + +pub(super) struct HostBudget { + pub limit: usize, + pub records: usize, + pub workspace: usize, + pub headroom: usize, + pub initial: usize, +} + +impl HostBudget { + pub(super) fn new( + lanes: usize, + executions: usize, + per_lane: usize, + detected: Option, + ceiling: Option, + cells: usize, + ) -> Result { + if lanes == 0 || executions == 0 || cells == 0 { + return Err( + "lanes, execution threads and trace-cell budget must be positive" + .into(), + ); + } + let requested = if per_lane == 0 { + detected.ok_or("cannot detect host memory; specify --max-ram per GPU")? + } else { + per_lane.checked_mul(lanes).ok_or("process host budget overflow")? + }; + let limit = ceiling.map_or(requested, |ceiling| requested.min(ceiling)); + let workspace = cells + .checked_mul(16) + .and_then(|n| n.checked_add(256 << 20)) + .and_then(|n| n.checked_mul(43)) + .map(|n| n.div_ceil(40)) + .ok_or("prover workspace budget overflow")?; + let headroom = limit / 10; + let reserved = workspace + .checked_mul(lanes) + .and_then(|n| n.checked_add(headroom)) + .ok_or("process workspace budget overflow")?; + let records = limit.checked_sub(reserved) + .ok_or("host budget cannot hold the GPU workers' workspace; raise --max-ram or lower AIUR_TRACE_SHARD_MAX_CELLS")?; + let slots = lanes + .checked_mul(2) + .and_then(|n| n.checked_add(executions)) + .ok_or("record admission count overflow")?; + let initial = records / slots; + if initial == 0 { + return Err("no host capacity remains for execution records".into()); + } + Ok(Self { limit, records, workspace, headroom, initial }) + } +} + +fn memory_limit_at(mount: &Path, group: &Path) -> Option { + let mut limit = None; + for path in group.ancestors().take_while(|path| path.starts_with(mount)) { + if let Some(bytes) = fs::read_to_string(path.join("memory.max")) + .ok() + .and_then(|s| s.trim().parse::().ok()) + { + limit = Some(limit.map_or(bytes, |old: usize| old.min(bytes))); + } + } + limit +} + +/// The tightest visible cgroup-v2 ancestor limit, also respecting a +/// cgroup namespace whose mount starts below the hierarchy root. +pub(super) fn cgroup_memory_limit() -> Option { + let membership = fs::read_to_string("/proc/self/cgroup").ok()?; + let group = membership.lines().find_map(|line| line.strip_prefix("0::"))?; + let mounts = fs::read_to_string("/proc/self/mountinfo").ok()?; + let mut limit = None; + for line in mounts.lines() { + let Some((fields, _)) = line.split_once(" - cgroup2 ") else { continue }; + let fields: Vec<_> = fields.split_whitespace().collect(); + let (Some(root), Some(mount)) = (fields.get(3), fields.get(4)) else { + continue; + }; + let mount = PathBuf::from(mount.replace("\\040", " ")); + let root = PathBuf::from(root.replace("\\040", " ")); + let relative = Path::new(group).strip_prefix(&root).ok()?; + if let Some(bytes) = memory_limit_at(&mount, &mount.join(relative)) { + limit = Some(limit.map_or(bytes, |old: usize| old.min(bytes))); + } + } + limit +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn per_lane_values_expand_once_and_auto_detection_is_global() { + let gib = 1usize << 30; + let explicit = + HostBudget::new(4, 12, 230 * gib, None, Some(920 * gib), 1_500_000_000) + .unwrap(); + assert_eq!(explicit.limit, 920 * gib); + assert_eq!( + explicit.records + explicit.workspace * 4 + explicit.headroom, + explicit.limit + ); + assert_eq!(explicit.initial, explicit.records / 20); + let auto = HostBudget::new( + 4, + 12, + 0, + Some(800 * gib), + Some(700 * gib), + 1_500_000_000, + ) + .unwrap(); + assert_eq!(auto.limit, 700 * gib); + assert!(HostBudget::new(4, 12, usize::MAX, None, None, 1).is_err()); + assert!(HostBudget::new(4, 12, 1, None, None, 1).is_err()); + } + + #[test] + fn cgroup_parent_limit_applies_when_leaf_is_unlimited() { + let mount = std::env::temp_dir() + .join(format!("ix-record-cgroup-{}", std::process::id())); + let group = mount.join("parent/leaf"); + fs::create_dir_all(&group).unwrap(); + fs::write(mount.join("memory.max"), "1000\n").unwrap(); + fs::write(mount.join("parent/memory.max"), "800\n").unwrap(); + fs::write(group.join("memory.max"), "max\n").unwrap(); + assert_eq!(memory_limit_at(&mount, &group), Some(800)); + fs::write(group.join("memory.max"), "600\n").unwrap(); + assert_eq!(memory_limit_at(&mount, &group), Some(600)); + fs::remove_dir_all(mount).unwrap(); + } +} diff --git a/crates/ffi/src/aiur/aggregate/lanes/queue.rs b/crates/ffi/src/aiur/aggregate/lanes/queue.rs new file mode 100644 index 000000000..4f8b3eb89 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/lanes/queue.rs @@ -0,0 +1,124 @@ +use std::collections::VecDeque; +use std::sync::{Condvar, Mutex}; + +struct State { + priority: VecDeque, + ordinary: VecDeque, + closed: bool, +} + +/// Bounded ownership transfer with ready joins ahead of claims. +pub(super) struct WorkQueue { + capacity: usize, + state: Mutex>, + changed: Condvar, +} + +impl WorkQueue { + pub(super) fn new(capacity: usize) -> Self { + assert!(capacity > 0); + Self { + capacity, + state: Mutex::new(State { + priority: VecDeque::new(), + ordinary: VecDeque::new(), + closed: false, + }), + changed: Condvar::new(), + } + } + + pub(super) fn push(&self, item: T, priority: bool) -> Result<(), T> { + let mut state = self.state.lock().unwrap(); + while !state.closed + && state.priority.len() + state.ordinary.len() == self.capacity + { + state = self.changed.wait(state).unwrap(); + } + if state.closed { + return Err(item); + } + if priority { + state.priority.push_back(item); + } else { + state.ordinary.push_back(item); + } + self.changed.notify_all(); + Ok(()) + } + + pub(super) fn pop(&self) -> Option { + let mut state = self.state.lock().unwrap(); + loop { + if state.closed { + return None; + } + if let Some(item) = + state.priority.pop_front().or_else(|| state.ordinary.pop_front()) + { + self.changed.notify_all(); + return Some(item); + } + state = self.changed.wait(state).unwrap(); + } + } + + pub(super) fn close(&self) { + let mut state = self.state.lock().unwrap(); + state.closed = true; + let priority = std::mem::take(&mut state.priority); + let ordinary = std::mem::take(&mut state.ordinary); + self.changed.notify_all(); + drop(state); + drop((priority, ordinary)); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::{ + sync::{Arc, mpsc}, + thread, + time::Duration, + }; + + #[test] + fn ready_joins_precede_claims_without_reordering_peers() { + let queue = WorkQueue::new(4); + queue.push(1, false).unwrap(); + queue.push(2, true).unwrap(); + queue.push(3, true).unwrap(); + queue.push(4, false).unwrap(); + assert_eq!( + (queue.pop(), queue.pop(), queue.pop(), queue.pop()), + (Some(2), Some(3), Some(1), Some(4)) + ); + } + + #[test] + fn closing_releases_items_and_wakes_producers_and_consumers() { + let full = Arc::new(WorkQueue::new(1)); + let stored = Arc::new(()); + full.push(Arc::clone(&stored), false).unwrap(); + let producer_queue = Arc::clone(&full); + let (tx, rx) = mpsc::channel(); + let producer = thread::spawn(move || { + tx.send(producer_queue.push(Arc::new(()), false).is_err()).unwrap(); + }); + full.close(); + assert_eq!(Arc::strong_count(&stored), 1); + assert!(rx.recv_timeout(Duration::from_secs(3)).unwrap()); + producer.join().unwrap(); + assert!(full.pop().is_none()); + + let empty = Arc::new(WorkQueue::::new(1)); + let consumer_queue = Arc::clone(&empty); + let (tx, rx) = mpsc::channel(); + let consumer = + thread::spawn(move || tx.send(consumer_queue.pop()).unwrap()); + empty.close(); + assert_eq!(rx.recv_timeout(Duration::from_secs(3)).unwrap(), None); + consumer.join().unwrap(); + } +} diff --git a/crates/ffi/src/aiur/aggregate/plan.rs b/crates/ffi/src/aiur/aggregate/plan.rs index b248b128f..109c06232 100644 --- a/crates/ffi/src/aiur/aggregate/plan.rs +++ b/crates/ffi/src/aiur/aggregate/plan.rs @@ -260,3 +260,81 @@ pub(super) fn plan_replay( || children.iter().any(|index| specs[*index].kind == ChildKind::Ixvm); Ok(ReplayPlan { children, needs_input_proofs }) } + +/// Leaves under every slot of a post-order plan. +pub(super) fn leaves_under(ops: &[PlanOp]) -> Vec { + let mut leaves = vec![0usize; ops.len()]; + for (index, op) in ops.iter().enumerate() { + leaves[index] = match *op { + PlanOp::Leaf(_) => 1, + PlanOp::Join(left, right) => leaves[left] + leaves[right], + }; + } + leaves +} + +/// Splits frontier node `at` into its children when it is a join. A child +/// that is a raw leaf becomes a one-leaf subtree: its claim proof is its +/// published proof, and the join above it verifies that raw leaf beside +/// its cached sibling. Returns whether it split. +fn split_frontier( + ops: &[PlanOp], + frontier: &mut Vec, + at: usize, +) -> bool { + let PlanOp::Join(left, right) = ops[frontier[at]] else { + return false; + }; + frontier.swap_remove(at); + frontier.push(left); + frontier.push(right); + true +} + +/// The plan cut into subtrees for dynamic scheduling: the tree is split from +/// the root while any frontier node holds more leaves than +/// `ceil(leaves / subtrees)`. Returns the frontier (the subtrees, post-order; +/// a subtree may be a single raw leaf) and every join above it (post-order, +/// so each appears after its children). A subtree of several leaves is +/// proven as one `--subtree` task once its leaves' claims exist; a +/// one-leaf subtree is published by its claim proof alone; an upper join +/// once both children are published; whichever device is free takes the +/// next ready task, so no packing is decided ahead of time. +pub(super) fn subtree_plan( + ops: &[PlanOp], + max_leaves: usize, +) -> (Vec, Vec) { + let Some(root) = ops.len().checked_sub(1) else { + return (Vec::new(), Vec::new()); + }; + let leaves = leaves_under(ops); + let target = max_leaves.max(1); + let mut frontier = vec![root]; + while let Some(at) = (0..frontier.len()) + .filter(|&at| leaves[frontier[at]] > target) + .max_by_key(|&at| leaves[frontier[at]]) + { + if !split_frontier(ops, &mut frontier, at) { + break; + } + } + frontier.sort_unstable(); + // Everything above the frontier: the ancestors of frontier nodes. + let mut above = vec![false; ops.len()]; + let mut in_frontier = vec![false; ops.len()]; + for &slot in &frontier { + in_frontier[slot] = true; + } + for index in 0..ops.len() { + if let PlanOp::Join(left, right) = ops[index] + && (in_frontier[left] + || in_frontier[right] + || above[left] + || above[right]) + { + above[index] = true; + } + } + let upper: Vec = (0..ops.len()).filter(|&i| above[i]).collect(); + (frontier, upper) +} diff --git a/crates/ffi/src/aiur/aggregate/tests.rs b/crates/ffi/src/aiur/aggregate/tests.rs index 1c7f24890..37027be5b 100644 --- a/crates/ffi/src/aiur/aggregate/tests.rs +++ b/crates/ffi/src/aiur/aggregate/tests.rs @@ -15,6 +15,7 @@ use std::sync::Arc; use ixon::{Axiom, Expr}; +mod plan; mod prepare; mod scheduler; mod store; diff --git a/crates/ffi/src/aiur/aggregate/tests/plan.rs b/crates/ffi/src/aiur/aggregate/tests/plan.rs new file mode 100644 index 000000000..5451abd54 --- /dev/null +++ b/crates/ffi/src/aiur/aggregate/tests/plan.rs @@ -0,0 +1,93 @@ +use super::super::plan::{PlanOp, leaves_under, subtree_plan}; + +/// A post-order plan from a nested leaf-count shape: `(a, b)` joins the +/// plans of `a` and `b`; a number is that many balanced leaves. +fn plan_of(shape: &str) -> Vec { + fn go(chars: &[u8], at: &mut usize, out: &mut Vec) -> usize { + if chars[*at] == b'(' { + *at += 1; + let left = go(chars, at, out); + assert_eq!(chars[*at], b','); + *at += 1; + let right = go(chars, at, out); + assert_eq!(chars[*at], b')'); + *at += 1; + out.push(PlanOp::Join(left, right)); + } else { + let start = *at; + while *at < chars.len() && chars[*at].is_ascii_digit() { + *at += 1; + } + let count: usize = + std::str::from_utf8(&chars[start..*at]).unwrap().parse().unwrap(); + let ids: Vec = (0..u32::try_from(count).unwrap()).collect(); + fn balanced(ids: &[u32], out: &mut Vec) -> usize { + if ids.len() == 1 { + out.push(PlanOp::Leaf(ids[0] as usize)); + } else { + let (l, r) = ids.split_at(ids.len() / 2); + let left = balanced(l, out); + let right = balanced(r, out); + out.push(PlanOp::Join(left, right)); + } + out.len() - 1 + } + balanced(&ids, out); + } + out.len() - 1 + } + let mut out = Vec::new(); + go(shape.as_bytes(), &mut 0, &mut out); + out +} + +#[test] +fn subtree_plan_cuts_to_the_target_and_lists_the_joins_above() { + let sizes = |ops: &[PlanOp], slots: &[usize]| -> Vec { + let leaves = leaves_under(ops); + slots.iter().map(|&s| leaves[s]).collect() + }; + // Balanced: a size of eight keeps the root whole; a size of two cuts + // to the depth-2 nodes, with the two depth-1 joins and the root above. + let ops = plan_of("8"); + let (frontier, upper) = subtree_plan(&ops, 8); + assert_eq!(frontier, vec![ops.len() - 1]); + assert!(upper.is_empty()); + let (frontier, upper) = subtree_plan(&ops, 2); + assert_eq!(sizes(&ops, &frontier), vec![2, 2, 2, 2]); + assert_eq!(upper.len(), 3); + assert_eq!(*upper.last().unwrap(), ops.len() - 1); + // Mathlib's 128-way shape at the top: root = (70, 58), 70 = (38, 32), + // 58 = (32, 26). A size of eight leaves nothing larger than that. + let ops = plan_of("((38,32),(32,26))"); + let (frontier, upper) = subtree_plan(&ops, 8); + let leaves = sizes(&ops, &frontier); + assert_eq!(leaves.iter().sum::(), 128); + assert!(leaves.iter().all(|n| (2..=8).contains(n))); + // Post-order: every upper join comes after its children. + let position = |slot: usize| upper.iter().position(|&s| s == slot); + for &slot in &upper { + let PlanOp::Join(left, right) = ops[slot] else { panic!("join") }; + for child in [left, right] { + if let Some(at) = position(child) { + assert!(at < position(slot).unwrap()); + } else { + assert!(frontier.contains(&child)); + } + } + } + // A lone leaf beside a subtree: the tree (1 + 32) + 16 has 49 leaves; + // a size of four means the 33-leaf node must be cut even though one of + // its children is a raw leaf, which then stands as a one-leaf subtree. + let ops = plan_of("((1,32),16)"); + let (frontier, _) = subtree_plan(&ops, 4); + let leaves = sizes(&ops, &frontier); + assert_eq!(leaves.iter().sum::(), 1 + 32 + 16); + assert!(leaves.iter().all(|&n| n <= 4)); + assert_eq!(leaves.iter().filter(|&&n| n == 1).count(), 1); + // A two-leaf tree at size one: two one-leaf subtrees under the root join. + let ops = plan_of("2"); + let (frontier, upper) = subtree_plan(&ops, 1); + assert_eq!(sizes(&ops, &frontier), vec![1, 1]); + assert_eq!(upper, vec![ops.len() - 1]); +} diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 3a28e05ef..3a1bc4ffd 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -2461,7 +2461,7 @@ pub extern "C" fn rs_shard_env_static( requested_shards } else if cfg!(feature = "cuda") { // The trace-shard prover: seed against one execution's record share, - // computed as `ix prove --exec-jobs` computes it. + // computed as `ix prove --lanes` computes it. let cells = crate::aiur::protocol::trace_shard_max_cells(); let budget = usize::try_from(ram_gib << 30).unwrap_or(usize::MAX); let share = diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index ce307db9b..1dc33f7c0 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -12,1253 +12,1253 @@ use aiur::execute::{ExecError, IOBuffer, QueryRecord}; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; -fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_1: usize = 2; const IN_1: usize = 2; const OUT_1: usize = 1; -fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = G::from_u64(256); let __v_67: G = (__v_9 * __v_66); let __v_68: G = (__v_67 + __v_8); let __v_69: G = (__v_68 * __v_66); let __v_70: G = (__v_69 + __v_7); let __v_71: G = (__v_70 * __v_66); let __v_72: G = (__v_71 + __v_6); let __v_73: G = (__v_72 * __v_66); let __v_74: G = (__v_73 + __v_5); let __v_75: G = (__v_74 * __v_66); let __v_76: G = (__v_75 + __v_4); let __v_77: G = (__v_76 * __v_66); let __v_78: G = (__v_77 + __v_3); let __v_79: G = (__v_41 * __v_66); let __v_80: G = (__v_79 + __v_40); let __v_81: G = (__v_80 * __v_66); let __v_82: G = (__v_81 + __v_39); let __v_83: G = (__v_82 * __v_66); let __v_84: G = (__v_83 + __v_38); let __v_85: G = (__v_84 * __v_66); let __v_86: G = (__v_85 + __v_37); let __v_87: G = (__v_86 * __v_66); let __v_88: G = (__v_87 + __v_36); let __v_89: G = (__v_88 * __v_66); let __v_90: G = (__v_89 + __v_35); let __v_91: G = (__v_78 - __v_90); match __v_91.as_canonical_u64() { 0u64 => { let __v_92: G = G::from_u64(256); let __v_93: G = (__v_16 * __v_92); let __v_94: G = (__v_93 + __v_15); let __v_95: G = (__v_94 * __v_92); let __v_96: G = (__v_95 + __v_14); let __v_97: G = (__v_96 * __v_92); let __v_98: G = (__v_97 + __v_13); let __v_99: G = (__v_98 * __v_92); let __v_100: G = (__v_99 + __v_12); let __v_101: G = (__v_100 * __v_92); let __v_102: G = (__v_101 + __v_11); let __v_103: G = (__v_102 * __v_92); let __v_104: G = (__v_103 + __v_10); let __v_105: G = (__v_48 * __v_92); let __v_106: G = (__v_105 + __v_47); let __v_107: G = (__v_106 * __v_92); let __v_108: G = (__v_107 + __v_46); let __v_109: G = (__v_108 * __v_92); let __v_110: G = (__v_109 + __v_45); let __v_111: G = (__v_110 * __v_92); let __v_112: G = (__v_111 + __v_44); let __v_113: G = (__v_112 * __v_92); let __v_114: G = (__v_113 + __v_43); let __v_115: G = (__v_114 * __v_92); let __v_116: G = (__v_115 + __v_42); let __v_117: G = (__v_104 - __v_116); match __v_117.as_canonical_u64() { 0u64 => { let __v_118: G = G::from_u64(256); let __v_119: G = (__v_23 * __v_118); let __v_120: G = (__v_119 + __v_22); let __v_121: G = (__v_120 * __v_118); let __v_122: G = (__v_121 + __v_21); let __v_123: G = (__v_122 * __v_118); let __v_124: G = (__v_123 + __v_20); let __v_125: G = (__v_124 * __v_118); let __v_126: G = (__v_125 + __v_19); let __v_127: G = (__v_126 * __v_118); let __v_128: G = (__v_127 + __v_18); let __v_129: G = (__v_128 * __v_118); let __v_130: G = (__v_129 + __v_17); let __v_131: G = (__v_55 * __v_118); let __v_132: G = (__v_131 + __v_54); let __v_133: G = (__v_132 * __v_118); let __v_134: G = (__v_133 + __v_53); let __v_135: G = (__v_134 * __v_118); let __v_136: G = (__v_135 + __v_52); let __v_137: G = (__v_136 * __v_118); let __v_138: G = (__v_137 + __v_51); let __v_139: G = (__v_138 * __v_118); let __v_140: G = (__v_139 + __v_50); let __v_141: G = (__v_140 * __v_118); let __v_142: G = (__v_141 + __v_49); let __v_143: G = (__v_130 - __v_142); match __v_143.as_canonical_u64() { 0u64 => { let __v_144: G = G::from_u64(256); let __v_145: G = (__v_30 * __v_144); let __v_146: G = (__v_145 + __v_29); let __v_147: G = (__v_146 * __v_144); let __v_148: G = (__v_147 + __v_28); let __v_149: G = (__v_148 * __v_144); let __v_150: G = (__v_149 + __v_27); let __v_151: G = (__v_150 * __v_144); let __v_152: G = (__v_151 + __v_26); let __v_153: G = (__v_152 * __v_144); let __v_154: G = (__v_153 + __v_25); let __v_155: G = (__v_154 * __v_144); let __v_156: G = (__v_155 + __v_24); let __v_157: G = (__v_62 * __v_144); let __v_158: G = (__v_157 + __v_61); let __v_159: G = (__v_158 * __v_144); let __v_160: G = (__v_159 + __v_60); let __v_161: G = (__v_160 * __v_144); let __v_162: G = (__v_161 + __v_59); let __v_163: G = (__v_162 * __v_144); let __v_164: G = (__v_163 + __v_58); let __v_165: G = (__v_164 * __v_144); let __v_166: G = (__v_165 + __v_57); let __v_167: G = (__v_166 * __v_144); let __v_168: G = (__v_167 + __v_56); let __v_169: G = (__v_156 - __v_168); match __v_169.as_canonical_u64() { 0u64 => { let __v_170: G = G::from_u64(256); let __v_171: G = (__v_33 * __v_170); let __v_172: G = (__v_171 + __v_32); let __v_173: G = (__v_172 * __v_170); let __v_174: G = (__v_173 + __v_31); let __v_175: G = (__v_65 * __v_170); let __v_176: G = (__v_175 + __v_64); let __v_177: G = (__v_176 * __v_170); let __v_178: G = (__v_177 + __v_63); let __v_179: G = (__v_174 - __v_178); match __v_179.as_canonical_u64() { 0u64 => { let __v_180: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_180: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_170: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_170]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_144: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_144]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_118: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_118]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_92: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_92]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = G::from_u64(256); let __v_67: G = __v_9 * __v_66; let __v_68: G = __v_67 + __v_8; let __v_69: G = __v_68 * __v_66; let __v_70: G = __v_69 + __v_7; let __v_71: G = __v_70 * __v_66; let __v_72: G = __v_71 + __v_6; let __v_73: G = __v_72 * __v_66; let __v_74: G = __v_73 + __v_5; let __v_75: G = __v_74 * __v_66; let __v_76: G = __v_75 + __v_4; let __v_77: G = __v_76 * __v_66; let __v_78: G = __v_77 + __v_3; let __v_79: G = __v_41 * __v_66; let __v_80: G = __v_79 + __v_40; let __v_81: G = __v_80 * __v_66; let __v_82: G = __v_81 + __v_39; let __v_83: G = __v_82 * __v_66; let __v_84: G = __v_83 + __v_38; let __v_85: G = __v_84 * __v_66; let __v_86: G = __v_85 + __v_37; let __v_87: G = __v_86 * __v_66; let __v_88: G = __v_87 + __v_36; let __v_89: G = __v_88 * __v_66; let __v_90: G = __v_89 + __v_35; let __v_91: G = __v_78 - __v_90; match __v_91.as_canonical_u64() { 0u64 => { let __v_92: G = G::from_u64(256); let __v_93: G = __v_16 * __v_92; let __v_94: G = __v_93 + __v_15; let __v_95: G = __v_94 * __v_92; let __v_96: G = __v_95 + __v_14; let __v_97: G = __v_96 * __v_92; let __v_98: G = __v_97 + __v_13; let __v_99: G = __v_98 * __v_92; let __v_100: G = __v_99 + __v_12; let __v_101: G = __v_100 * __v_92; let __v_102: G = __v_101 + __v_11; let __v_103: G = __v_102 * __v_92; let __v_104: G = __v_103 + __v_10; let __v_105: G = __v_48 * __v_92; let __v_106: G = __v_105 + __v_47; let __v_107: G = __v_106 * __v_92; let __v_108: G = __v_107 + __v_46; let __v_109: G = __v_108 * __v_92; let __v_110: G = __v_109 + __v_45; let __v_111: G = __v_110 * __v_92; let __v_112: G = __v_111 + __v_44; let __v_113: G = __v_112 * __v_92; let __v_114: G = __v_113 + __v_43; let __v_115: G = __v_114 * __v_92; let __v_116: G = __v_115 + __v_42; let __v_117: G = __v_104 - __v_116; match __v_117.as_canonical_u64() { 0u64 => { let __v_118: G = G::from_u64(256); let __v_119: G = __v_23 * __v_118; let __v_120: G = __v_119 + __v_22; let __v_121: G = __v_120 * __v_118; let __v_122: G = __v_121 + __v_21; let __v_123: G = __v_122 * __v_118; let __v_124: G = __v_123 + __v_20; let __v_125: G = __v_124 * __v_118; let __v_126: G = __v_125 + __v_19; let __v_127: G = __v_126 * __v_118; let __v_128: G = __v_127 + __v_18; let __v_129: G = __v_128 * __v_118; let __v_130: G = __v_129 + __v_17; let __v_131: G = __v_55 * __v_118; let __v_132: G = __v_131 + __v_54; let __v_133: G = __v_132 * __v_118; let __v_134: G = __v_133 + __v_53; let __v_135: G = __v_134 * __v_118; let __v_136: G = __v_135 + __v_52; let __v_137: G = __v_136 * __v_118; let __v_138: G = __v_137 + __v_51; let __v_139: G = __v_138 * __v_118; let __v_140: G = __v_139 + __v_50; let __v_141: G = __v_140 * __v_118; let __v_142: G = __v_141 + __v_49; let __v_143: G = __v_130 - __v_142; match __v_143.as_canonical_u64() { 0u64 => { let __v_144: G = G::from_u64(256); let __v_145: G = __v_30 * __v_144; let __v_146: G = __v_145 + __v_29; let __v_147: G = __v_146 * __v_144; let __v_148: G = __v_147 + __v_28; let __v_149: G = __v_148 * __v_144; let __v_150: G = __v_149 + __v_27; let __v_151: G = __v_150 * __v_144; let __v_152: G = __v_151 + __v_26; let __v_153: G = __v_152 * __v_144; let __v_154: G = __v_153 + __v_25; let __v_155: G = __v_154 * __v_144; let __v_156: G = __v_155 + __v_24; let __v_157: G = __v_62 * __v_144; let __v_158: G = __v_157 + __v_61; let __v_159: G = __v_158 * __v_144; let __v_160: G = __v_159 + __v_60; let __v_161: G = __v_160 * __v_144; let __v_162: G = __v_161 + __v_59; let __v_163: G = __v_162 * __v_144; let __v_164: G = __v_163 + __v_58; let __v_165: G = __v_164 * __v_144; let __v_166: G = __v_165 + __v_57; let __v_167: G = __v_166 * __v_144; let __v_168: G = __v_167 + __v_56; let __v_169: G = __v_156 - __v_168; match __v_169.as_canonical_u64() { 0u64 => { let __v_170: G = G::from_u64(256); let __v_171: G = __v_33 * __v_170; let __v_172: G = __v_171 + __v_32; let __v_173: G = __v_172 * __v_170; let __v_174: G = __v_173 + __v_31; let __v_175: G = __v_65 * __v_170; let __v_176: G = __v_175 + __v_64; let __v_177: G = __v_176 * __v_170; let __v_178: G = __v_177 + __v_63; let __v_179: G = __v_174 - __v_178; match __v_179.as_canonical_u64() { 0u64 => { let __v_180: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_180: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_170: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_170]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_144: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_144]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_118: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_118]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_92: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_92]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_2: usize = 2; const IN_2: usize = 2; const OUT_2: usize = 1; -fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, (&__args[..]))?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __v_2 - __v_34; match __v_66.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, &__args[..])?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_3: usize = 3; const IN_3: usize = 3; const OUT_3: usize = 1; -fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_3] = [__v_4]; record.function_queries[3].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_5]; 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_6: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_3] = [__v_9]; record.function_queries[3].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_3] = [__v_4]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_5]; 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_6: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_3] = [__v_9]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_4: usize = 8; const IN_4: usize = 8; const OUT_4: usize = 1; -fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_5: usize = 8; const IN_5: usize = 8; const OUT_5: usize = 4; -fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __u32_sum: u128 = (u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_13: G = (__v_12 * __v_12); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __u32_sum: u128 = u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_13: G = __v_12 * __v_12; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_6: usize = 12; const IN_6: usize = 12; const OUT_6: usize = 4; -fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); let __v_13: G = G::from_u8(__u32_bytes[1]); let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_u64(2); let __v_20: G = (__v_16 - __v_19); let __v_21: G = (__v_18 * __v_20); let __v_22: G = (__v_16 * __v_21); let __v_23: G = G::from_u64(0); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; 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]; let __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_6] = [__v_12, __v_13, __v_14, __v_15]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_7: usize = 8; const IN_7: usize = 8; const OUT_7: usize = 4; -fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[7].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_8: usize = 4; const IN_8: usize = 4; const OUT_8: usize = 4; -fn aiur_fn_8(inp: [G; IN_8], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[8].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_8(inp: [G; IN_8], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[8].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_9: usize = 4; const IN_9: usize = 4; const OUT_9: usize = 4; -fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[9].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[9].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_10: usize = 8; const IN_10: usize = 8; const OUT_10: usize = 4; -fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); let __v_17: G = (__v_10 + __v_13); let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_8 + __v_11; let __v_17: G = __v_10 + __v_13; let __v_18: G = __v_12 + __v_15; let __v_19: G = __v_14 + __v_9; let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_11: usize = 8; const IN_11: usize = 8; const OUT_11: usize = 4; -fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); let __v_17: G = (__v_12 + __v_15); let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_10 + __v_13; let __v_17: G = __v_12 + __v_15; let __v_18: G = __v_14 + __v_9; let __v_19: G = __v_8 + __v_11; let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_12: usize = 16; const IN_12: usize = 16; const OUT_12: usize = 1; -fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = (__v_0 - __v_8); let __v_17: G = (__v_1 - __v_9); let __v_18: G = (__v_2 - __v_10); let __v_19: G = (__v_3 - __v_11); let __v_20: G = (__v_4 - __v_12); let __v_21: G = (__v_5 - __v_13); let __v_22: G = (__v_6 - __v_14); let __v_23: G = (__v_7 - __v_15); match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = __v_0 - __v_8; let __v_17: G = __v_1 - __v_9; let __v_18: G = __v_2 - __v_10; let __v_19: G = __v_3 - __v_11; let __v_20: G = __v_4 - __v_12; let __v_21: G = __v_5 - __v_13; let __v_22: G = __v_6 - __v_14; let __v_23: G = __v_7 - __v_15; match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_13: usize = 8; const IN_13: usize = 8; const OUT_13: usize = 8; -fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_7 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_6 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_7 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_6 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_5 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 + __v_9; let __ret: [G; OUT_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_0 + __v_8; let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_14: usize = 8; const IN_14: usize = 8; const OUT_14: usize = 1; -fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_1); let __v_11: G = 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_14] = [__v_26]; record.function_queries[14].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(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_14] = [__v_26]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_15: usize = 8; const IN_15: usize = 8; const OUT_15: usize = 1; -fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(256); let __v_9: G = (__v_8 * __v_1); let __v_10: G = G::from_u64(65536); let __v_11: G = (__v_10 * __v_2); let __v_12: G = G::from_u64(16777216); let __v_13: G = (__v_12 * __v_3); let __v_14: G = G::from_u64(4294967296); let __v_15: G = (__v_14 * __v_4); let __v_16: G = G::from_u64(1099511627776); let __v_17: G = (__v_16 * __v_5); let __v_18: G = G::from_u64(281474976710656); let __v_19: G = (__v_18 * __v_6); let __v_20: G = G::from_u64(72057594037927936); let __v_21: G = (__v_20 * __v_7); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_15 + __v_23); let __v_25: G = (__v_13 + __v_24); let __v_26: G = (__v_11 + __v_25); let __v_27: G = (__v_9 + __v_26); let __v_28: G = (__v_0 + __v_27); let __ret: [G; OUT_15] = [__v_28]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(256); let __v_9: G = __v_8 * __v_1; let __v_10: G = G::from_u64(65536); let __v_11: G = __v_10 * __v_2; let __v_12: G = G::from_u64(16777216); let __v_13: G = __v_12 * __v_3; let __v_14: G = G::from_u64(4294967296); let __v_15: G = __v_14 * __v_4; let __v_16: G = G::from_u64(1099511627776); let __v_17: G = __v_16 * __v_5; let __v_18: G = G::from_u64(281474976710656); let __v_19: G = __v_18 * __v_6; let __v_20: G = G::from_u64(72057594037927936); let __v_21: G = __v_20 * __v_7; let __v_22: G = __v_19 + __v_21; let __v_23: G = __v_17 + __v_22; let __v_24: G = __v_15 + __v_23; let __v_25: G = __v_13 + __v_24; let __v_26: G = __v_11 + __v_25; let __v_27: G = __v_9 + __v_26; let __v_28: G = __v_0 + __v_27; let __ret: [G; OUT_15] = [__v_28]; record.function_queries[15].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_16: usize = 8; const IN_16: usize = 8; const OUT_16: usize = 1; -fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_4 + __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = (__v_2 + __v_3); let __v_15: G = (__v_1 + __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_bool((__v_16 == G::ZERO)); let __v_18: G = G::from_u64(1); let __v_19: G = (__v_18 - __v_17); let __v_20: G = (__v_13 * __v_19); let __v_21: G = (__v_18 - __v_20); let __ret: [G; OUT_16] = [__v_21]; record.function_queries[16].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = __v_7 - __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_5 + __v_10; let __v_12: G = __v_4 + __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_2 + __v_3; let __v_15: G = __v_1 + __v_14; let __v_16: G = __v_0 + __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = G::from_u64(1); let __v_19: G = __v_18 - __v_17; let __v_20: G = __v_13 * __v_19; let __v_21: G = __v_18 - __v_20; let __ret: [G; OUT_16] = [__v_21]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_17: usize = 1; const IN_17: usize = 1; const OUT_17: usize = 8; -fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); let __v_3: G = G::from_u8(__gb[2]); let __v_4: G = G::from_u8(__gb[3]); let __v_5: G = G::from_u8(__gb[4]); let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_2); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_3); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_4); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_5); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_6); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_7); let __v_21: G = G::from_u64(72057594037927936); let __v_22: G = (__v_21 * __v_8); let __v_23: G = (__v_20 + __v_22); let __v_24: G = (__v_18 + __v_23); let __v_25: G = (__v_16 + __v_24); let __v_26: G = (__v_14 + __v_25); let __v_27: G = (__v_12 + __v_26); let __v_28: G = (__v_10 + __v_27); let __v_29: G = (__v_1 + __v_28); if (__v_29 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_30: G = G::from_u64(1020); let __v_31: G = (__v_8 - __v_30); let __v_32: G = (__v_7 + __v_31); let __v_33: G = (__v_6 + __v_32); let __v_34: G = (__v_5 + __v_33); let __v_35: G = G::from_bool((__v_34 == G::ZERO)); let __v_36: G = (__v_3 + __v_4); let __v_37: G = (__v_2 + __v_36); let __v_38: G = (__v_1 + __v_37); let __v_39: G = G::from_bool((__v_38 == G::ZERO)); let __v_40: G = G::from_u64(1); let __v_41: G = (__v_40 - __v_39); let __v_42: G = (__v_35 * __v_41); let __v_43: G = (__v_40 - __v_42); if (__v_43 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); let __v_3: G = G::from_u8(__gb[2]); let __v_4: G = G::from_u8(__gb[3]); let __v_5: G = G::from_u8(__gb[4]); let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_2; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_3; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_4; let __v_15: G = G::from_u64(4294967296); let __v_16: G = __v_15 * __v_5; let __v_17: G = G::from_u64(1099511627776); let __v_18: G = __v_17 * __v_6; let __v_19: G = G::from_u64(281474976710656); let __v_20: G = __v_19 * __v_7; let __v_21: G = G::from_u64(72057594037927936); let __v_22: G = __v_21 * __v_8; let __v_23: G = __v_20 + __v_22; let __v_24: G = __v_18 + __v_23; let __v_25: G = __v_16 + __v_24; let __v_26: G = __v_14 + __v_25; let __v_27: G = __v_12 + __v_26; let __v_28: G = __v_10 + __v_27; let __v_29: G = __v_1 + __v_28; if (__v_29 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_30: G = G::from_u64(1020); let __v_31: G = __v_8 - __v_30; let __v_32: G = __v_7 + __v_31; let __v_33: G = __v_6 + __v_32; let __v_34: G = __v_5 + __v_33; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = __v_3 + __v_4; let __v_37: G = __v_2 + __v_36; let __v_38: G = __v_1 + __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = G::from_u64(1); let __v_41: G = __v_40 - __v_39; let __v_42: G = __v_35 * __v_41; let __v_43: G = __v_40 - __v_42; if (__v_43 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_18: usize = 1; const IN_18: usize = 1; const OUT_18: usize = 1; -fn aiur_fn_18(inp: [G; IN_18], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = aiur::execute::g_inverse_value(__v_0); let __v_2: G = (__v_0 * __v_1); let __v_3: G = G::from_u64(1); let __v_4: G = (__v_2 - __v_3); let __v_5: G = (__v_0 * __v_4); let __v_6: G = G::from_u64(0); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_7: G = (__v_1 * __v_4); if (__v_7 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_18] = [__v_1]; record.function_queries[18].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_18(inp: [G; IN_18], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = aiur::execute::g_inverse_value(__v_0); let __v_2: G = __v_0 * __v_1; let __v_3: G = G::from_u64(1); let __v_4: G = __v_2 - __v_3; let __v_5: G = __v_0 * __v_4; let __v_6: G = G::from_u64(0); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_7: G = __v_1 * __v_4; if (__v_7 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_18] = [__v_1]; record.function_queries[18].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_19: usize = 4; const IN_19: usize = 4; const OUT_19: usize = 2; -fn aiur_fn_19(inp: [G; IN_19], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 + __v_2); let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_19] = [__v_4, __v_5]; record.function_queries[19].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_19(inp: [G; IN_19], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 + __v_2; let __v_5: G = __v_1 + __v_3; let __ret: [G; OUT_19] = [__v_4, __v_5]; record.function_queries[19].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_20: usize = 4; const IN_20: usize = 4; const OUT_20: usize = 2; -fn aiur_fn_20(inp: [G; IN_20], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_20] = [__v_4, __v_5]; record.function_queries[20].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_20(inp: [G; IN_20], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 - __v_2; let __v_5: G = __v_1 - __v_3; let __ret: [G; OUT_20] = [__v_4, __v_5]; record.function_queries[20].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_21: usize = 2; const IN_21: usize = 2; const OUT_21: usize = 2; -fn aiur_fn_21(inp: [G; IN_21], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = (__v_2 - __v_0); let __v_4: G = (__v_2 - __v_1); let __ret: [G; OUT_21] = [__v_3, __v_4]; record.function_queries[21].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_21(inp: [G; IN_21], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = __v_2 - __v_0; let __v_4: G = __v_2 - __v_1; let __ret: [G; OUT_21] = [__v_3, __v_4]; record.function_queries[21].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_22: usize = 4; const IN_22: usize = 4; const OUT_22: usize = 2; -fn aiur_fn_22(inp: [G; IN_22], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_1 * __v_3); let __v_7: G = (__v_5 * __v_6); let __v_8: G = (__v_4 + __v_7); let __v_9: G = (__v_0 * __v_3); let __v_10: G = (__v_1 * __v_2); let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_22] = [__v_8, __v_11]; record.function_queries[22].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_22(inp: [G; IN_22], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 * __v_2; let __v_5: G = G::from_u64(7); let __v_6: G = __v_1 * __v_3; let __v_7: G = __v_5 * __v_6; let __v_8: G = __v_4 + __v_7; let __v_9: G = __v_0 * __v_3; let __v_10: G = __v_1 * __v_2; let __v_11: G = __v_9 + __v_10; let __ret: [G; OUT_22] = [__v_8, __v_11]; record.function_queries[22].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_23: usize = 2; const IN_23: usize = 2; const OUT_23: usize = 2; -fn aiur_fn_23(inp: [G; IN_23], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 * __v_0); let __v_3: G = G::from_u64(7); let __v_4: G = (__v_1 * __v_1); let __v_5: G = (__v_3 * __v_4); let __v_6: G = (__v_2 - __v_5); let __v_7: G = aiur::execute::g_inverse_value(__v_6); let __v_8: G = (__v_6 * __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 - __v_9); let __v_11: G = (__v_6 * __v_10); let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_13: G = (__v_7 * __v_10); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_14: G = (__v_0 * __v_7); let __v_15: G = (__v_12 - __v_1); let __v_16: G = (__v_15 * __v_7); let __ret: [G; OUT_23] = [__v_14, __v_16]; record.function_queries[23].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_23(inp: [G; IN_23], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = __v_0 * __v_0; let __v_3: G = G::from_u64(7); let __v_4: G = __v_1 * __v_1; let __v_5: G = __v_3 * __v_4; let __v_6: G = __v_2 - __v_5; let __v_7: G = aiur::execute::g_inverse_value(__v_6); let __v_8: G = __v_6 * __v_7; let __v_9: G = G::from_u64(1); let __v_10: G = __v_8 - __v_9; let __v_11: G = __v_6 * __v_10; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_13: G = __v_7 * __v_10; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_14: G = __v_0 * __v_7; let __v_15: G = __v_12 - __v_1; let __v_16: G = __v_15 * __v_7; let __ret: [G; OUT_23] = [__v_14, __v_16]; record.function_queries[23].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_24: usize = 4; const IN_24: usize = 4; const OUT_24: usize = 2; -fn aiur_fn_24(inp: [G; IN_24], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_2 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_3 * __v_3); let __v_7: G = (__v_5 * __v_6); let __v_8: G = (__v_4 - __v_7); let __v_9: G = aiur::execute::g_inverse_value(__v_8); let __v_10: G = (__v_8 * __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 - __v_11); let __v_13: G = (__v_8 * __v_12); let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_9 * __v_12); if (__v_15 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_16: G = (__v_2 * __v_9); let __v_17: G = (__v_14 - __v_3); let __v_18: G = (__v_17 * __v_9); let __v_19: G = (__v_0 * __v_16); let __v_20: G = (__v_1 * __v_18); let __v_21: G = (__v_5 * __v_20); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_0 * __v_18); let __v_24: G = (__v_1 * __v_16); let __v_25: G = (__v_23 + __v_24); let __ret: [G; OUT_24] = [__v_22, __v_25]; record.function_queries[24].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_24(inp: [G; IN_24], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_2 * __v_2; let __v_5: G = G::from_u64(7); let __v_6: G = __v_3 * __v_3; let __v_7: G = __v_5 * __v_6; let __v_8: G = __v_4 - __v_7; let __v_9: G = aiur::execute::g_inverse_value(__v_8); let __v_10: G = __v_8 * __v_9; let __v_11: G = G::from_u64(1); let __v_12: G = __v_10 - __v_11; let __v_13: G = __v_8 * __v_12; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = __v_9 * __v_12; if (__v_15 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_16: G = __v_2 * __v_9; let __v_17: G = __v_14 - __v_3; let __v_18: G = __v_17 * __v_9; let __v_19: G = __v_0 * __v_16; let __v_20: G = __v_1 * __v_18; let __v_21: G = __v_5 * __v_20; let __v_22: G = __v_19 + __v_21; let __v_23: G = __v_0 * __v_18; let __v_24: G = __v_1 * __v_16; let __v_25: G = __v_23 + __v_24; let __ret: [G; OUT_24] = [__v_22, __v_25]; record.function_queries[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_25: usize = 4; const IN_25: usize = 4; const OUT_25: usize = 1; -fn aiur_fn_25(inp: [G; IN_25], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_1 - __v_3); let __v_7: G = G::from_bool((__v_6 == G::ZERO)); let __v_8: G = (__v_5 * __v_7); let __ret: [G; OUT_25] = [__v_8]; record.function_queries[25].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_25(inp: [G; IN_25], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 - __v_2; let __v_5: G = G::from_bool(__v_4 == G::ZERO); let __v_6: G = __v_1 - __v_3; let __v_7: G = G::from_bool(__v_6 == G::ZERO); let __v_8: G = __v_5 * __v_7; let __ret: [G; OUT_25] = [__v_8]; record.function_queries[25].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_26: usize = 1; const IN_26: usize = 1; const OUT_26: usize = 2; -fn aiur_fn_26(inp: [G; IN_26], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_26] = [__v_2, __v_3]; record.function_queries[26].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_26] = [__v_4, __v_6]; record.function_queries[26].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_26(inp: [G; IN_26], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_26] = [__v_2, __v_3]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_26] = [__v_4, __v_6]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_27: usize = 1; const IN_27: usize = 1; const OUT_27: usize = 9; -fn aiur_fn_27(inp: [G; IN_27], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_27] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[27].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_27(inp: [G; IN_27], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_27] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_28: usize = 1; const IN_28: usize = 1; const OUT_28: usize = 2; -fn aiur_fn_28(inp: [G; IN_28], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_10, __v_9]; record.function_queries[28].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_28(inp: [G; IN_28], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_10, __v_9]; record.function_queries[28].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_29: usize = 1; const IN_29: usize = 1; const OUT_29: usize = 2; -fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_29] = [__v_2, __v_4]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 + __v_3; let __ret: [G; OUT_29] = [__v_2, __v_4]; record.function_queries[29].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_30: usize = 1; const IN_30: usize = 1; const OUT_30: usize = 9; -fn aiur_fn_30(inp: [G; IN_30], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = __io_read[1]; let __v_4: G = __io_read[2]; let __v_5: G = __io_read[3]; let __v_6: G = __io_read[4]; let __v_7: G = __io_read[5]; let __v_8: G = __io_read[6]; let __v_9: G = __io_read[7]; let __v_10: G = G::from_u64(8); let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_30] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_30(inp: [G; IN_30], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = __io_read[1]; let __v_4: G = __io_read[2]; let __v_5: G = __io_read[3]; let __v_6: G = __io_read[4]; let __v_7: G = __io_read[5]; let __v_8: G = __io_read[6]; let __v_9: G = __io_read[7]; let __v_10: G = G::from_u64(8); let __v_11: G = __v_0 + __v_10; let __ret: [G; OUT_30] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[30].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_31: usize = 1; const IN_31: usize = 1; const OUT_31: usize = 2; -fn aiur_fn_31(inp: [G; IN_31], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_10, __v_9]; record.function_queries[31].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_31(inp: [G; IN_31], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_10, __v_9]; record.function_queries[31].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_32: usize = 1; const IN_32: usize = 1; const OUT_32: usize = 3; -fn aiur_fn_32(inp: [G; IN_32], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = G::from_u64(256); let __v_20: G = (__v_19 * __v_2); let __v_21: G = G::from_u64(65536); let __v_22: G = (__v_21 * __v_3); let __v_23: G = G::from_u64(16777216); let __v_24: G = (__v_23 * __v_4); let __v_25: G = G::from_u64(4294967296); let __v_26: G = (__v_25 * __v_5); let __v_27: G = G::from_u64(1099511627776); let __v_28: G = (__v_27 * __v_6); let __v_29: G = G::from_u64(281474976710656); let __v_30: G = (__v_29 * __v_7); let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = (__v_31 * __v_8); let __v_33: G = (__v_30 + __v_32); let __v_34: G = (__v_28 + __v_33); let __v_35: G = (__v_26 + __v_34); let __v_36: G = (__v_24 + __v_35); let __v_37: G = (__v_22 + __v_36); let __v_38: G = (__v_20 + __v_37); let __v_39: G = (__v_1 + __v_38); let __v_40: G = (__v_19 * __v_11); let __v_41: G = (__v_21 * __v_12); let __v_42: G = (__v_23 * __v_13); let __v_43: G = (__v_25 * __v_14); let __v_44: G = (__v_27 * __v_15); let __v_45: G = (__v_29 * __v_16); let __v_46: G = (__v_31 * __v_17); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_44 + __v_47); let __v_49: G = (__v_43 + __v_48); let __v_50: G = (__v_42 + __v_49); let __v_51: G = (__v_41 + __v_50); let __v_52: G = (__v_40 + __v_51); let __v_53: G = (__v_10 + __v_52); let __ret: [G; OUT_32] = [__v_39, __v_53, __v_18]; record.function_queries[32].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_32(inp: [G; IN_32], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = G::from_u64(256); let __v_20: G = __v_19 * __v_2; let __v_21: G = G::from_u64(65536); let __v_22: G = __v_21 * __v_3; let __v_23: G = G::from_u64(16777216); let __v_24: G = __v_23 * __v_4; let __v_25: G = G::from_u64(4294967296); let __v_26: G = __v_25 * __v_5; let __v_27: G = G::from_u64(1099511627776); let __v_28: G = __v_27 * __v_6; let __v_29: G = G::from_u64(281474976710656); let __v_30: G = __v_29 * __v_7; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_8; let __v_33: G = __v_30 + __v_32; let __v_34: G = __v_28 + __v_33; let __v_35: G = __v_26 + __v_34; let __v_36: G = __v_24 + __v_35; let __v_37: G = __v_22 + __v_36; let __v_38: G = __v_20 + __v_37; let __v_39: G = __v_1 + __v_38; let __v_40: G = __v_19 * __v_11; let __v_41: G = __v_21 * __v_12; let __v_42: G = __v_23 * __v_13; let __v_43: G = __v_25 * __v_14; let __v_44: G = __v_27 * __v_15; let __v_45: G = __v_29 * __v_16; let __v_46: G = __v_31 * __v_17; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_44 + __v_47; let __v_49: G = __v_43 + __v_48; let __v_50: G = __v_42 + __v_49; let __v_51: G = __v_41 + __v_50; let __v_52: G = __v_40 + __v_51; let __v_53: G = __v_10 + __v_52; let __ret: [G; OUT_32] = [__v_39, __v_53, __v_18]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_33: usize = 1; const IN_33: usize = 1; const OUT_33: usize = 33; -fn aiur_fn_33(inp: [G; IN_33], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_33(inp: [G; IN_33], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_34: usize = 1; const IN_34: usize = 1; const OUT_34: usize = 2; -fn aiur_fn_34(inp: [G; IN_34], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_34(inp: [G; IN_34], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_35: usize = 2; const IN_35: usize = 2; const OUT_35: usize = 2; -fn aiur_fn_35(inp: [G; IN_35], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_3, __v_0]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_9, __v_7]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_35(inp: [G; IN_35], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_3, __v_0]; record.function_queries[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_9, __v_7]; record.function_queries[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_36: usize = 1; const IN_36: usize = 1; const OUT_36: usize = 2; -fn aiur_fn_36(inp: [G; IN_36], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, (&__args[..]))?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { (*(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37])) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_36(inp: [G; IN_36], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, &__args[..])?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_37: usize = 2; const IN_37: usize = 2; const OUT_37: usize = 2; -fn aiur_fn_37(inp: [G; IN_37], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, (&__args[..]))?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { (*(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37])) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_16, __v_14]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_37(inp: [G; IN_37], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, &__args[..])?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_16, __v_14]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_38: usize = 1; const IN_38: usize = 1; const OUT_38: usize = 2; -fn aiur_fn_38(inp: [G; IN_38], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, (&__args[..]))?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { (*(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39])) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_38(inp: [G; IN_38], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, &__args[..])?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_39: usize = 2; const IN_39: usize = 2; const OUT_39: usize = 2; -fn aiur_fn_39(inp: [G; IN_39], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = G::from_u64(256); let __v_21: G = (__v_20 * __v_3); let __v_22: G = G::from_u64(65536); let __v_23: G = (__v_22 * __v_4); let __v_24: G = G::from_u64(16777216); let __v_25: G = (__v_24 * __v_5); let __v_26: G = G::from_u64(4294967296); let __v_27: G = (__v_26 * __v_6); let __v_28: G = G::from_u64(1099511627776); let __v_29: G = (__v_28 * __v_7); let __v_30: G = G::from_u64(281474976710656); let __v_31: G = (__v_30 * __v_8); let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = (__v_32 * __v_9); let __v_34: G = (__v_31 + __v_33); let __v_35: G = (__v_29 + __v_34); let __v_36: G = (__v_27 + __v_35); let __v_37: G = (__v_25 + __v_36); let __v_38: G = (__v_23 + __v_37); let __v_39: G = (__v_21 + __v_38); let __v_40: G = (__v_2 + __v_39); let __v_41: G = (__v_20 * __v_12); let __v_42: G = (__v_22 * __v_13); let __v_43: G = (__v_24 * __v_14); let __v_44: G = (__v_26 * __v_15); let __v_45: G = (__v_28 * __v_16); let __v_46: G = (__v_30 * __v_17); let __v_47: G = (__v_32 * __v_18); let __v_48: G = (__v_46 + __v_47); let __v_49: G = (__v_45 + __v_48); let __v_50: G = (__v_44 + __v_49); let __v_51: G = (__v_43 + __v_50); let __v_52: G = (__v_42 + __v_51); let __v_53: G = (__v_41 + __v_52); let __v_54: G = (__v_11 + __v_53); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_1 - __v_55); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, (&__args[..]))?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { (*(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39])) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_59, __v_40, __v_54, __v_57]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_60, __v_58]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_39(inp: [G; IN_39], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = G::from_u64(256); let __v_21: G = __v_20 * __v_3; let __v_22: G = G::from_u64(65536); let __v_23: G = __v_22 * __v_4; let __v_24: G = G::from_u64(16777216); let __v_25: G = __v_24 * __v_5; let __v_26: G = G::from_u64(4294967296); let __v_27: G = __v_26 * __v_6; let __v_28: G = G::from_u64(1099511627776); let __v_29: G = __v_28 * __v_7; let __v_30: G = G::from_u64(281474976710656); let __v_31: G = __v_30 * __v_8; let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = __v_32 * __v_9; let __v_34: G = __v_31 + __v_33; let __v_35: G = __v_29 + __v_34; let __v_36: G = __v_27 + __v_35; let __v_37: G = __v_25 + __v_36; let __v_38: G = __v_23 + __v_37; let __v_39: G = __v_21 + __v_38; let __v_40: G = __v_2 + __v_39; let __v_41: G = __v_20 * __v_12; let __v_42: G = __v_22 * __v_13; let __v_43: G = __v_24 * __v_14; let __v_44: G = __v_26 * __v_15; let __v_45: G = __v_28 * __v_16; let __v_46: G = __v_30 * __v_17; let __v_47: G = __v_32 * __v_18; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_45 + __v_48; let __v_50: G = __v_44 + __v_49; let __v_51: G = __v_43 + __v_50; let __v_52: G = __v_42 + __v_51; let __v_53: G = __v_41 + __v_52; let __v_54: G = __v_11 + __v_53; let __v_55: G = G::from_u64(1); let __v_56: G = __v_1 - __v_55; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, &__args[..])?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_59, __v_40, __v_54, __v_57]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_60, __v_58]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_40: usize = 1; const IN_40: usize = 1; const OUT_40: usize = 2; -fn aiur_fn_40(inp: [G; IN_40], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_40(inp: [G; IN_40], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_41: usize = 2; const IN_41: usize = 2; const OUT_41: usize = 2; -fn aiur_fn_41(inp: [G; IN_41], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_3, __v_0]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_44, __v_41]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_41(inp: [G; IN_41], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_3, __v_0]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_44, __v_41]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_42: usize = 1; const IN_42: usize = 1; const OUT_42: usize = 2; -fn aiur_fn_42(inp: [G; IN_42], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_42(inp: [G; IN_42], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_43: usize = 2; const IN_43: usize = 2; const OUT_43: usize = 2; -fn aiur_fn_43(inp: [G; IN_43], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_3, __v_0]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_9, __v_7]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_43(inp: [G; IN_43], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_3, __v_0]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_9, __v_7]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_44: usize = 1; const IN_44: usize = 1; const OUT_44: usize = 2; -fn aiur_fn_44(inp: [G; IN_44], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_44(inp: [G; IN_44], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_45: usize = 2; const IN_45: usize = 2; const OUT_45: usize = 2; -fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_3, __v_0]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_11, __v_9]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_3, __v_0]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_11, __v_9]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_46: usize = 1; const IN_46: usize = 1; const OUT_46: usize = 2; -fn aiur_fn_46(inp: [G; IN_46], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_3, __v_4]; record.function_queries[46].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_46(inp: [G; IN_46], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_3, __v_4]; record.function_queries[46].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_47: usize = 2; const IN_47: usize = 2; const OUT_47: usize = 2; -fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_3, __v_0]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_9, __v_7]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_3, __v_0]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_9, __v_7]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_48: usize = 1; const IN_48: usize = 1; const OUT_48: usize = 2; -fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, (&__args[..]))?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { (*(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49])) }; __ret }, _ => { aiur_fn_49::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_3, __v_4]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, &__args[..])?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => { aiur_fn_49::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_3, __v_4]; record.function_queries[48].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_49: usize = 2; const IN_49: usize = 2; const OUT_49: usize = 2; -fn aiur_fn_49(inp: [G; IN_49], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_49] = [__v_3, __v_0]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, (&__args[..]))?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { (*(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49])) }; __ret }, _ => { aiur_fn_49::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_49] = [__v_9, __v_7]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_49(inp: [G; IN_49], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_49] = [__v_3, __v_0]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, &__args[..])?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => { aiur_fn_49::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_49] = [__v_9, __v_7]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_50: usize = 1; const IN_50: usize = 1; const OUT_50: usize = 2; -fn aiur_fn_50(inp: [G; IN_50], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_1, __v_2]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_50(inp: [G; IN_50], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_1, __v_2]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_51: usize = 1; const IN_51: usize = 1; const OUT_51: usize = 2; -fn aiur_fn_51(inp: [G; IN_51], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, (&__args[..]))?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { (*(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52])) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_3, __v_4]; record.function_queries[51].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_51(inp: [G; IN_51], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_3, __v_4]; record.function_queries[51].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_52: usize = 2; const IN_52: usize = 2; const OUT_52: usize = 2; -fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_52] = [__v_3, __v_0]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, (&__args[..]))?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { (*(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52])) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_52] = [__v_9, __v_7]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_52] = [__v_3, __v_0]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_52] = [__v_9, __v_7]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_53: usize = 1; const IN_53: usize = 1; const OUT_53: usize = 4; -fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[53].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_54: usize = 1; const IN_54: usize = 1; const OUT_54: usize = 3; -fn aiur_fn_54(inp: [G; IN_54], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_54] = [__v_3, __v_5, __v_6]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_54(inp: [G; IN_54], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_54] = [__v_3, __v_5, __v_6]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_55: usize = 1; const IN_55: usize = 1; const OUT_55: usize = 2; -fn aiur_fn_55(inp: [G; IN_55], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, (&__args[..]))?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { (*(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56])) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_3, __v_4]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_55(inp: [G; IN_55], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_3, __v_4]; record.function_queries[55].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_56: usize = 2; const IN_56: usize = 2; const OUT_56: usize = 2; -fn aiur_fn_56(inp: [G; IN_56], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_56] = [__v_3, __v_0]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, (&__args[..]))?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { (*(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56])) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_56] = [__v_13, __v_11]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_56(inp: [G; IN_56], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_56] = [__v_3, __v_0]; record.function_queries[56].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_56] = [__v_13, __v_11]; record.function_queries[56].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_57: usize = 1; const IN_57: usize = 1; const OUT_57: usize = 4; -fn aiur_fn_57(inp: [G; IN_57], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_1, __v_5, __v_7, __v_8]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_57(inp: [G; IN_57], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_1, __v_5, __v_7, __v_8]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_58: usize = 1; const IN_58: usize = 1; const OUT_58: usize = 2; -fn aiur_fn_58(inp: [G; IN_58], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, (&__args[..]))?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { (*(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59])) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_58] = [__v_3, __v_4]; record.function_queries[58].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_58(inp: [G; IN_58], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, &__args[..])?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_58] = [__v_3, __v_4]; record.function_queries[58].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_59: usize = 2; const IN_59: usize = 2; const OUT_59: usize = 2; -fn aiur_fn_59(inp: [G; IN_59], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 5] = [__v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 5)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_59] = [__v_3, __v_0]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, (&__args[..]))?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { (*(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59])) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 5)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_59] = [__v_15, __v_13]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_59(inp: [G; IN_59], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 5] = [__v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 5)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_59] = [__v_3, __v_0]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = __v_1 - __v_10; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, &__args[..])?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 5)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_59] = [__v_15, __v_13]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_60: usize = 1; const IN_60: usize = 1; const OUT_60: usize = 14; -fn aiur_fn_60(inp: [G; IN_60], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, (&__args[..]))?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { (*(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52])) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, (&__args[..]))?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { (*(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56])) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, (&__args[..]))?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { (*(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59])) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __ret: [G; OUT_60] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[60].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_60(inp: [G; IN_60], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, &__args[..])?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __ret: [G; OUT_60] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_61: usize = 1; const IN_61: usize = 1; const OUT_61: usize = 3; -fn aiur_fn_61(inp: [G; IN_61], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_61] = [__v_3, __v_3, __v_2]; record.function_queries[61].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, (&__args[..]))?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { (*(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48])) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_61] = [__v_5, __v_3, __v_4]; record.function_queries[61].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_61(inp: [G; IN_61], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_61] = [__v_3, __v_3, __v_2]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_61] = [__v_5, __v_3, __v_4]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_62: usize = 1; const IN_62: usize = 1; const OUT_62: usize = 25; -fn aiur_fn_62(inp: [G; IN_62], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, (&__args[..]))?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { (*(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52])) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, (&__args[..]))?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { (*(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56])) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_28, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, (&__args[..]))?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { (*(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59])) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; let __v_36: G = __r_arr[3]; let __v_37: G = __r_arr[4]; let __v_38: G = __r_arr[5]; let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, (&__args[..]))?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { (*(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48])) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(61, (&__args[..]))?) { [G::ZERO; OUT_61] } else { let (__hash, __hit) = record.function_queries[61].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[61].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { (*(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61])) }; __ret }, _ => { aiur_fn_61::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, (&__args[..]))?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { (*(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48])) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, (&__args[..]))?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { (*(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48])) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_62] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; record.function_queries[62].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_62(inp: [G; IN_62], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_28, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, &__args[..])?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; let __v_36: G = __r_arr[3]; let __v_37: G = __r_arr[4]; let __v_38: G = __r_arr[5]; let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(61, &__args[..])?) { [G::ZERO; OUT_61] } else { let (__hash, __hit) = record.function_queries[61].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[61].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => { aiur_fn_61::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_62] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; record.function_queries[62].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_63: usize = 1; const IN_63: usize = 1; const OUT_63: usize = 5; -fn aiur_fn_63(inp: [G; IN_63], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_63] = [__v_3, __v_5, __v_9, __v_13, __v_14]; record.function_queries[63].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_63(inp: [G; IN_63], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_63] = [__v_3, __v_5, __v_9, __v_13, __v_14]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_64: usize = 1; const IN_64: usize = 1; const OUT_64: usize = 2; -fn aiur_fn_64(inp: [G; IN_64], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, (&__args[..]))?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { (*(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65])) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_64] = [__v_3, __v_4]; record.function_queries[64].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_64(inp: [G; IN_64], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_64] = [__v_3, __v_4]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_65: usize = 2; const IN_65: usize = 2; const OUT_65: usize = 2; -fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_65] = [__v_3, __v_0]; record.function_queries[65].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, (&__args[..]))?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { (*(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40])) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_1 - __v_16); let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, (&__args[..]))?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { (*(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65])) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 6] = [__v_20, __v_4, __v_6, __v_10, __v_14, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_65] = [__v_21, __v_19]; record.function_queries[65].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_65] = [__v_3, __v_0]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(1); let __v_17: G = __v_1 - __v_16; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 6] = [__v_20, __v_4, __v_6, __v_10, __v_14, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_65] = [__v_21, __v_19]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_66: usize = 1; const IN_66: usize = 1; const OUT_66: usize = 10; -fn aiur_fn_66(inp: [G; IN_66], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __ret: [G; OUT_66] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_66(inp: [G; IN_66], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __ret: [G; OUT_66] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[66].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_67: usize = 1; const IN_67: usize = 1; const OUT_67: usize = 2; -fn aiur_fn_67(inp: [G; IN_67], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_67] = [__v_3, __v_4]; record.function_queries[67].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_67(inp: [G; IN_67], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_67] = [__v_3, __v_4]; record.function_queries[67].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_68: usize = 2; const IN_68: usize = 2; const OUT_68: usize = 2; -fn aiur_fn_68(inp: [G; IN_68], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_3, __v_0]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { (*(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30])) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 11] = [__v_17, __v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_15]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_18, __v_16]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_68(inp: [G; IN_68], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_3, __v_0]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = G::from_u64(1); let __v_14: G = __v_1 - __v_13; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 11] = [__v_17, __v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_15]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_18, __v_16]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_69: usize = 1; const IN_69: usize = 1; const OUT_69: usize = 2; -fn aiur_fn_69(inp: [G; IN_69], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, (&__args[..]))?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { (*(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70])) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_4]; record.function_queries[69].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_69(inp: [G; IN_69], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_4]; record.function_queries[69].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_70: usize = 2; const IN_70: usize = 2; const OUT_70: usize = 2; -fn aiur_fn_70(inp: [G; IN_70], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 26] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 26)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_70] = [__v_3, __v_0]; record.function_queries[70].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, (&__args[..]))?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { (*(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62])) }; __ret }, _ => { aiur_fn_62::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = G::from_u64(1); let __v_28: G = (__v_1 - __v_27); let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, (&__args[..]))?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { (*(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70])) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 26] = [__v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 26)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_70] = [__v_32, __v_30]; record.function_queries[70].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_70(inp: [G; IN_70], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 26] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 26)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_70] = [__v_3, __v_0]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, &__args[..])?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => { aiur_fn_62::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = G::from_u64(1); let __v_28: G = __v_1 - __v_27; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 26] = [__v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 26)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_70] = [__v_32, __v_30]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_71: usize = 1; const IN_71: usize = 1; const OUT_71: usize = 4; -fn aiur_fn_71(inp: [G; IN_71], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, (&__args[..]))?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { (*(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65])) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, (&__args[..]))?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { (*(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70])) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_71] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[71].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_71(inp: [G; IN_71], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_71] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[71].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_72: usize = 4; const IN_72: usize = 4; const OUT_72: usize = 1; -fn aiur_fn_72(inp: [G; IN_72], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = 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_72] = [__v_12]; record.function_queries[72].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_72(inp: [G; IN_72], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = 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_72] = [__v_12]; record.function_queries[72].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_73: usize = 32; const IN_73: usize = 32; const OUT_73: usize = 8; -fn aiur_fn_73(inp: [G; IN_73], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = 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_73] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_73(inp: [G; IN_73], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = __v_32 * __v_1; let __v_34: G = 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_73] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_74: usize = 1; const IN_74: usize = 1; const OUT_74: usize = 32; -fn aiur_fn_74(inp: [G; IN_74], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_74] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_74(inp: [G; IN_74], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_74] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_75: usize = 1; const IN_75: usize = 1; const OUT_75: usize = 1; -fn aiur_fn_75(inp: [G; IN_75], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_75] = [__v_71]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_75(inp: [G; IN_75], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_75] = [__v_71]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_76: usize = 34; const IN_76: usize = 34; const OUT_76: usize = 34; -fn aiur_fn_76(inp: [G; IN_76], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __loaded[32]; let __v_67: G = __loaded[33]; match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_76] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, (&__args[..]))?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { (*(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76])) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; let __v_72: G = __r_arr[3]; let __v_73: G = __r_arr[4]; let __v_74: G = __r_arr[5]; let __v_75: G = __r_arr[6]; let __v_76: G = __r_arr[7]; let __v_77: G = __r_arr[8]; let __v_78: G = __r_arr[9]; let __v_79: G = __r_arr[10]; let __v_80: G = __r_arr[11]; let __v_81: G = __r_arr[12]; let __v_82: G = __r_arr[13]; let __v_83: G = __r_arr[14]; let __v_84: G = __r_arr[15]; let __v_85: G = __r_arr[16]; let __v_86: G = __r_arr[17]; let __v_87: G = __r_arr[18]; let __v_88: G = __r_arr[19]; let __v_89: G = __r_arr[20]; let __v_90: G = __r_arr[21]; let __v_91: G = __r_arr[22]; let __v_92: G = __r_arr[23]; let __v_93: G = __r_arr[24]; let __v_94: G = __r_arr[25]; let __v_95: G = __r_arr[26]; let __v_96: G = __r_arr[27]; let __v_97: G = __r_arr[28]; let __v_98: G = __r_arr[29]; let __v_99: G = __r_arr[30]; let __v_100: G = __r_arr[31]; let __v_101: G = __r_arr[32]; let __v_102: G = __r_arr[33]; match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_76] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_103: G = G::from_u64(4); let __v_104: G = G::from_u64(8); let __v_105: G = G::from_u64(103); let __v_106: G = G::from_u64(230); let __v_107: G = G::from_u64(9); let __v_108: G = G::from_u64(106); let __v_109: G = G::from_u64(133); let __v_110: G = G::from_u64(174); let __v_111: G = G::from_u64(187); let __v_112: G = G::from_u64(114); let __v_113: G = G::from_u64(243); let __v_114: G = G::from_u64(110); let __v_115: G = G::from_u64(60); let __v_116: G = G::from_u64(58); let __v_117: G = G::from_u64(245); let __v_118: G = G::from_u64(79); let __v_119: G = G::from_u64(165); let __v_120: G = G::from_u64(127); let __v_121: G = G::from_u64(82); let __v_122: G = G::from_u64(14); let __v_123: G = G::from_u64(81); let __v_124: G = G::from_u64(140); let __v_125: G = G::from_u64(104); let __v_126: G = G::from_u64(5); let __v_127: G = G::from_u64(155); let __v_128: G = G::from_u64(171); let __v_129: G = G::from_u64(217); let __v_130: G = G::from_u64(131); let __v_131: G = G::from_u64(31); let __v_132: G = G::from_u64(25); let __v_133: G = G::from_u64(205); let __v_134: G = G::from_u64(224); let __v_135: G = G::from_u64(91); let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; let __v_139: G = __loaded[3]; let __v_140: G = __loaded[4]; let __v_141: G = __loaded[5]; let __v_142: G = __loaded[6]; let __v_143: G = __loaded[7]; let __v_144: G = __loaded[8]; let __v_145: G = __loaded[9]; let __v_146: G = __loaded[10]; let __v_147: G = __loaded[11]; let __v_148: G = __loaded[12]; let __v_149: G = __loaded[13]; let __v_150: G = __loaded[14]; let __v_151: G = __loaded[15]; let __v_152: G = __loaded[16]; let __v_153: G = __loaded[17]; let __v_154: G = __loaded[18]; let __v_155: G = __loaded[19]; let __v_156: G = __loaded[20]; let __v_157: G = __loaded[21]; let __v_158: G = __loaded[22]; let __v_159: G = __loaded[23]; let __v_160: G = __loaded[24]; let __v_161: G = __loaded[25]; let __v_162: G = __loaded[26]; let __v_163: G = __loaded[27]; let __v_164: G = __loaded[28]; let __v_165: G = __loaded[29]; let __v_166: G = __loaded[30]; let __v_167: G = __loaded[31]; let __v_168: G = __loaded[32]; let __v_169: G = __loaded[33]; match __v_136.as_canonical_u64() { 1u64 => { let __v_170: G = (__v_104 * __v_33); let __v_171: G = (__v_103 + __v_170); let __v_172: G = G::from_u64(0); let __v_173: G = G::from_u64(64); let __v_174: G = G::from_u64(103); let __v_175: G = G::from_u64(230); let __v_176: G = G::from_u64(9); let __v_177: G = G::from_u64(106); let __v_178: G = G::from_u64(133); let __v_179: G = G::from_u64(174); let __v_180: G = G::from_u64(187); let __v_181: G = G::from_u64(114); let __v_182: G = G::from_u64(243); let __v_183: G = G::from_u64(110); let __v_184: G = G::from_u64(60); let __v_185: G = G::from_u64(58); let __v_186: G = G::from_u64(245); let __v_187: G = G::from_u64(79); let __v_188: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_172, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_174, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_173, __v_172, __v_172, __v_172, __v_171, __v_172, __v_172, __v_172, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; let __v_192: G = __r_arr[3]; let __v_193: G = __r_arr[4]; let __v_194: G = __r_arr[5]; let __v_195: G = __r_arr[6]; let __v_196: G = __r_arr[7]; let __v_197: G = __r_arr[8]; let __v_198: G = __r_arr[9]; let __v_199: G = __r_arr[10]; let __v_200: G = __r_arr[11]; let __v_201: G = __r_arr[12]; let __v_202: G = __r_arr[13]; let __v_203: G = __r_arr[14]; let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; let __v_207: G = __r_arr[18]; let __v_208: G = __r_arr[19]; let __v_209: G = __r_arr[20]; let __v_210: G = __r_arr[21]; let __v_211: G = __r_arr[22]; let __v_212: G = __r_arr[23]; let __v_213: G = __r_arr[24]; let __v_214: G = __r_arr[25]; let __v_215: G = __r_arr[26]; let __v_216: G = __r_arr[27]; let __v_217: G = __r_arr[28]; let __v_218: G = __r_arr[29]; let __v_219: G = __r_arr[30]; let __v_220: G = __r_arr[31]; let __v_221: G = { let __values: [G; 34] = [__v_172, __v_102, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_76] = [__v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_221]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(64); let __v_172: G = G::from_u64(103); let __v_173: G = G::from_u64(230); let __v_174: G = G::from_u64(9); let __v_175: G = G::from_u64(106); let __v_176: G = G::from_u64(133); let __v_177: G = G::from_u64(174); let __v_178: G = G::from_u64(187); let __v_179: G = G::from_u64(114); let __v_180: G = G::from_u64(243); let __v_181: G = G::from_u64(110); let __v_182: G = G::from_u64(60); let __v_183: G = G::from_u64(58); let __v_184: G = G::from_u64(245); let __v_185: G = G::from_u64(79); let __v_186: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_170, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_172, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_171, __v_170, __v_170, __v_170, __v_103, __v_170, __v_170, __v_170, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; let __v_190: G = __r_arr[3]; let __v_191: G = __r_arr[4]; let __v_192: G = __r_arr[5]; let __v_193: G = __r_arr[6]; let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; let __v_197: G = __r_arr[10]; let __v_198: G = __r_arr[11]; let __v_199: G = __r_arr[12]; let __v_200: G = __r_arr[13]; let __v_201: G = __r_arr[14]; let __v_202: G = __r_arr[15]; let __v_203: G = __r_arr[16]; let __v_204: G = __r_arr[17]; let __v_205: G = __r_arr[18]; let __v_206: G = __r_arr[19]; let __v_207: G = __r_arr[20]; let __v_208: G = __r_arr[21]; let __v_209: G = __r_arr[22]; let __v_210: G = __r_arr[23]; let __v_211: G = __r_arr[24]; let __v_212: G = __r_arr[25]; let __v_213: G = __r_arr[26]; let __v_214: G = __r_arr[27]; let __v_215: G = __r_arr[28]; let __v_216: G = __r_arr[29]; let __v_217: G = __r_arr[30]; let __v_218: G = __r_arr[31]; let __v_219: G = { let __values: [G; 34] = [__v_170, __v_102, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_76] = [__v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_219]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } +fn aiur_fn_76(inp: [G; IN_76], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __loaded[32]; let __v_67: G = __loaded[33]; match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_76] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, &__args[..])?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; let __v_72: G = __r_arr[3]; let __v_73: G = __r_arr[4]; let __v_74: G = __r_arr[5]; let __v_75: G = __r_arr[6]; let __v_76: G = __r_arr[7]; let __v_77: G = __r_arr[8]; let __v_78: G = __r_arr[9]; let __v_79: G = __r_arr[10]; let __v_80: G = __r_arr[11]; let __v_81: G = __r_arr[12]; let __v_82: G = __r_arr[13]; let __v_83: G = __r_arr[14]; let __v_84: G = __r_arr[15]; let __v_85: G = __r_arr[16]; let __v_86: G = __r_arr[17]; let __v_87: G = __r_arr[18]; let __v_88: G = __r_arr[19]; let __v_89: G = __r_arr[20]; let __v_90: G = __r_arr[21]; let __v_91: G = __r_arr[22]; let __v_92: G = __r_arr[23]; let __v_93: G = __r_arr[24]; let __v_94: G = __r_arr[25]; let __v_95: G = __r_arr[26]; let __v_96: G = __r_arr[27]; let __v_97: G = __r_arr[28]; let __v_98: G = __r_arr[29]; let __v_99: G = __r_arr[30]; let __v_100: G = __r_arr[31]; let __v_101: G = __r_arr[32]; let __v_102: G = __r_arr[33]; match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_76] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_103: G = G::from_u64(4); let __v_104: G = G::from_u64(8); let __v_105: G = G::from_u64(103); let __v_106: G = G::from_u64(230); let __v_107: G = G::from_u64(9); let __v_108: G = G::from_u64(106); let __v_109: G = G::from_u64(133); let __v_110: G = G::from_u64(174); let __v_111: G = G::from_u64(187); let __v_112: G = G::from_u64(114); let __v_113: G = G::from_u64(243); let __v_114: G = G::from_u64(110); let __v_115: G = G::from_u64(60); let __v_116: G = G::from_u64(58); let __v_117: G = G::from_u64(245); let __v_118: G = G::from_u64(79); let __v_119: G = G::from_u64(165); let __v_120: G = G::from_u64(127); let __v_121: G = G::from_u64(82); let __v_122: G = G::from_u64(14); let __v_123: G = G::from_u64(81); let __v_124: G = G::from_u64(140); let __v_125: G = G::from_u64(104); let __v_126: G = G::from_u64(5); let __v_127: G = G::from_u64(155); let __v_128: G = G::from_u64(171); let __v_129: G = G::from_u64(217); let __v_130: G = G::from_u64(131); let __v_131: G = G::from_u64(31); let __v_132: G = G::from_u64(25); let __v_133: G = G::from_u64(205); let __v_134: G = G::from_u64(224); let __v_135: G = G::from_u64(91); let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; let __v_139: G = __loaded[3]; let __v_140: G = __loaded[4]; let __v_141: G = __loaded[5]; let __v_142: G = __loaded[6]; let __v_143: G = __loaded[7]; let __v_144: G = __loaded[8]; let __v_145: G = __loaded[9]; let __v_146: G = __loaded[10]; let __v_147: G = __loaded[11]; let __v_148: G = __loaded[12]; let __v_149: G = __loaded[13]; let __v_150: G = __loaded[14]; let __v_151: G = __loaded[15]; let __v_152: G = __loaded[16]; let __v_153: G = __loaded[17]; let __v_154: G = __loaded[18]; let __v_155: G = __loaded[19]; let __v_156: G = __loaded[20]; let __v_157: G = __loaded[21]; let __v_158: G = __loaded[22]; let __v_159: G = __loaded[23]; let __v_160: G = __loaded[24]; let __v_161: G = __loaded[25]; let __v_162: G = __loaded[26]; let __v_163: G = __loaded[27]; let __v_164: G = __loaded[28]; let __v_165: G = __loaded[29]; let __v_166: G = __loaded[30]; let __v_167: G = __loaded[31]; let __v_168: G = __loaded[32]; let __v_169: G = __loaded[33]; match __v_136.as_canonical_u64() { 1u64 => { let __v_170: G = __v_104 * __v_33; let __v_171: G = __v_103 + __v_170; let __v_172: G = G::from_u64(0); let __v_173: G = G::from_u64(64); let __v_174: G = G::from_u64(103); let __v_175: G = G::from_u64(230); let __v_176: G = G::from_u64(9); let __v_177: G = G::from_u64(106); let __v_178: G = G::from_u64(133); let __v_179: G = G::from_u64(174); let __v_180: G = G::from_u64(187); let __v_181: G = G::from_u64(114); let __v_182: G = G::from_u64(243); let __v_183: G = G::from_u64(110); let __v_184: G = G::from_u64(60); let __v_185: G = G::from_u64(58); let __v_186: G = G::from_u64(245); let __v_187: G = G::from_u64(79); let __v_188: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_172, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_174, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_173, __v_172, __v_172, __v_172, __v_171, __v_172, __v_172, __v_172, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; let __v_192: G = __r_arr[3]; let __v_193: G = __r_arr[4]; let __v_194: G = __r_arr[5]; let __v_195: G = __r_arr[6]; let __v_196: G = __r_arr[7]; let __v_197: G = __r_arr[8]; let __v_198: G = __r_arr[9]; let __v_199: G = __r_arr[10]; let __v_200: G = __r_arr[11]; let __v_201: G = __r_arr[12]; let __v_202: G = __r_arr[13]; let __v_203: G = __r_arr[14]; let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; let __v_207: G = __r_arr[18]; let __v_208: G = __r_arr[19]; let __v_209: G = __r_arr[20]; let __v_210: G = __r_arr[21]; let __v_211: G = __r_arr[22]; let __v_212: G = __r_arr[23]; let __v_213: G = __r_arr[24]; let __v_214: G = __r_arr[25]; let __v_215: G = __r_arr[26]; let __v_216: G = __r_arr[27]; let __v_217: G = __r_arr[28]; let __v_218: G = __r_arr[29]; let __v_219: G = __r_arr[30]; let __v_220: G = __r_arr[31]; let __v_221: G = { let __values: [G; 34] = [__v_172, __v_102, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_76] = [__v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_221]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(64); let __v_172: G = G::from_u64(103); let __v_173: G = G::from_u64(230); let __v_174: G = G::from_u64(9); let __v_175: G = G::from_u64(106); let __v_176: G = G::from_u64(133); let __v_177: G = G::from_u64(174); let __v_178: G = G::from_u64(187); let __v_179: G = G::from_u64(114); let __v_180: G = G::from_u64(243); let __v_181: G = G::from_u64(110); let __v_182: G = G::from_u64(60); let __v_183: G = G::from_u64(58); let __v_184: G = G::from_u64(245); let __v_185: G = G::from_u64(79); let __v_186: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_170, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_172, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_171, __v_170, __v_170, __v_170, __v_103, __v_170, __v_170, __v_170, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; let __v_190: G = __r_arr[3]; let __v_191: G = __r_arr[4]; let __v_192: G = __r_arr[5]; let __v_193: G = __r_arr[6]; let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; let __v_197: G = __r_arr[10]; let __v_198: G = __r_arr[11]; let __v_199: G = __r_arr[12]; let __v_200: G = __r_arr[13]; let __v_201: G = __r_arr[14]; let __v_202: G = __r_arr[15]; let __v_203: G = __r_arr[16]; let __v_204: G = __r_arr[17]; let __v_205: G = __r_arr[18]; let __v_206: G = __r_arr[19]; let __v_207: G = __r_arr[20]; let __v_208: G = __r_arr[21]; let __v_209: G = __r_arr[22]; let __v_210: G = __r_arr[23]; let __v_211: G = __r_arr[24]; let __v_212: G = __r_arr[25]; let __v_213: G = __r_arr[26]; let __v_214: G = __r_arr[27]; let __v_215: G = __r_arr[28]; let __v_216: G = __r_arr[29]; let __v_217: G = __r_arr[30]; let __v_218: G = __r_arr[31]; let __v_219: G = { let __values: [G; 34] = [__v_170, __v_102, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_76] = [__v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_219]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } const INPUT_SIZE_77: usize = 1; const IN_77: usize = 1; const OUT_77: usize = 32; -fn aiur_fn_77(inp: [G; IN_77], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; let __v_67: G = __loaded[32]; let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_77] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, (&__args[..]))?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { (*(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76])) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; let __v_73: G = __r_arr[3]; let __v_74: G = __r_arr[4]; let __v_75: G = __r_arr[5]; let __v_76: G = __r_arr[6]; let __v_77: G = __r_arr[7]; let __v_78: G = __r_arr[8]; let __v_79: G = __r_arr[9]; let __v_80: G = __r_arr[10]; let __v_81: G = __r_arr[11]; let __v_82: G = __r_arr[12]; let __v_83: G = __r_arr[13]; let __v_84: G = __r_arr[14]; let __v_85: G = __r_arr[15]; let __v_86: G = __r_arr[16]; let __v_87: G = __r_arr[17]; let __v_88: G = __r_arr[18]; let __v_89: G = __r_arr[19]; let __v_90: G = __r_arr[20]; let __v_91: G = __r_arr[21]; let __v_92: G = __r_arr[22]; let __v_93: G = __r_arr[23]; let __v_94: G = __r_arr[24]; let __v_95: G = __r_arr[25]; let __v_96: G = __r_arr[26]; let __v_97: G = __r_arr[27]; let __v_98: G = __r_arr[28]; let __v_99: G = __r_arr[29]; let __v_100: G = __r_arr[30]; let __v_101: G = __r_arr[31]; let __v_102: G = __r_arr[32]; let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; let __v_107: G = __r_arr[3]; let __v_108: G = __r_arr[4]; let __v_109: G = __r_arr[5]; let __v_110: G = __r_arr[6]; let __v_111: G = __r_arr[7]; let __v_112: G = __r_arr[8]; let __v_113: G = __r_arr[9]; let __v_114: G = __r_arr[10]; let __v_115: G = __r_arr[11]; let __v_116: G = __r_arr[12]; let __v_117: G = __r_arr[13]; let __v_118: G = __r_arr[14]; let __v_119: G = __r_arr[15]; let __v_120: G = __r_arr[16]; let __v_121: G = __r_arr[17]; let __v_122: G = __r_arr[18]; let __v_123: G = __r_arr[19]; let __v_124: G = __r_arr[20]; let __v_125: G = __r_arr[21]; let __v_126: G = __r_arr[22]; let __v_127: G = __r_arr[23]; let __v_128: G = __r_arr[24]; let __v_129: G = __r_arr[25]; let __v_130: G = __r_arr[26]; let __v_131: G = __r_arr[27]; let __v_132: G = __r_arr[28]; let __v_133: G = __r_arr[29]; let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_77] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; let __v_109: G = __r_arr[3]; let __v_110: G = __r_arr[4]; let __v_111: G = __r_arr[5]; let __v_112: G = __r_arr[6]; let __v_113: G = __r_arr[7]; let __v_114: G = __r_arr[8]; let __v_115: G = __r_arr[9]; let __v_116: G = __r_arr[10]; let __v_117: G = __r_arr[11]; let __v_118: G = __r_arr[12]; let __v_119: G = __r_arr[13]; let __v_120: G = __r_arr[14]; let __v_121: G = __r_arr[15]; let __v_122: G = __r_arr[16]; let __v_123: G = __r_arr[17]; let __v_124: G = __r_arr[18]; let __v_125: G = __r_arr[19]; let __v_126: G = __r_arr[20]; let __v_127: G = __r_arr[21]; let __v_128: G = __r_arr[22]; let __v_129: G = __r_arr[23]; let __v_130: G = __r_arr[24]; let __v_131: G = __r_arr[25]; let __v_132: G = __r_arr[26]; let __v_133: G = __r_arr[27]; let __v_134: G = __r_arr[28]; let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_77] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_77(inp: [G; IN_77], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; let __v_67: G = __loaded[32]; let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_77] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, &__args[..])?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; let __v_73: G = __r_arr[3]; let __v_74: G = __r_arr[4]; let __v_75: G = __r_arr[5]; let __v_76: G = __r_arr[6]; let __v_77: G = __r_arr[7]; let __v_78: G = __r_arr[8]; let __v_79: G = __r_arr[9]; let __v_80: G = __r_arr[10]; let __v_81: G = __r_arr[11]; let __v_82: G = __r_arr[12]; let __v_83: G = __r_arr[13]; let __v_84: G = __r_arr[14]; let __v_85: G = __r_arr[15]; let __v_86: G = __r_arr[16]; let __v_87: G = __r_arr[17]; let __v_88: G = __r_arr[18]; let __v_89: G = __r_arr[19]; let __v_90: G = __r_arr[20]; let __v_91: G = __r_arr[21]; let __v_92: G = __r_arr[22]; let __v_93: G = __r_arr[23]; let __v_94: G = __r_arr[24]; let __v_95: G = __r_arr[25]; let __v_96: G = __r_arr[26]; let __v_97: G = __r_arr[27]; let __v_98: G = __r_arr[28]; let __v_99: G = __r_arr[29]; let __v_100: G = __r_arr[30]; let __v_101: G = __r_arr[31]; let __v_102: G = __r_arr[32]; let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; let __v_107: G = __r_arr[3]; let __v_108: G = __r_arr[4]; let __v_109: G = __r_arr[5]; let __v_110: G = __r_arr[6]; let __v_111: G = __r_arr[7]; let __v_112: G = __r_arr[8]; let __v_113: G = __r_arr[9]; let __v_114: G = __r_arr[10]; let __v_115: G = __r_arr[11]; let __v_116: G = __r_arr[12]; let __v_117: G = __r_arr[13]; let __v_118: G = __r_arr[14]; let __v_119: G = __r_arr[15]; let __v_120: G = __r_arr[16]; let __v_121: G = __r_arr[17]; let __v_122: G = __r_arr[18]; let __v_123: G = __r_arr[19]; let __v_124: G = __r_arr[20]; let __v_125: G = __r_arr[21]; let __v_126: G = __r_arr[22]; let __v_127: G = __r_arr[23]; let __v_128: G = __r_arr[24]; let __v_129: G = __r_arr[25]; let __v_130: G = __r_arr[26]; let __v_131: G = __r_arr[27]; let __v_132: G = __r_arr[28]; let __v_133: G = __r_arr[29]; let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_77] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; let __v_109: G = __r_arr[3]; let __v_110: G = __r_arr[4]; let __v_111: G = __r_arr[5]; let __v_112: G = __r_arr[6]; let __v_113: G = __r_arr[7]; let __v_114: G = __r_arr[8]; let __v_115: G = __r_arr[9]; let __v_116: G = __r_arr[10]; let __v_117: G = __r_arr[11]; let __v_118: G = __r_arr[12]; let __v_119: G = __r_arr[13]; let __v_120: G = __r_arr[14]; let __v_121: G = __r_arr[15]; let __v_122: G = __r_arr[16]; let __v_123: G = __r_arr[17]; let __v_124: G = __r_arr[18]; let __v_125: G = __r_arr[19]; let __v_126: G = __r_arr[20]; let __v_127: G = __r_arr[21]; let __v_128: G = __r_arr[22]; let __v_129: G = __r_arr[23]; let __v_130: G = __r_arr[24]; let __v_131: G = __r_arr[25]; let __v_132: G = __r_arr[26]; let __v_133: G = __r_arr[27]; let __v_134: G = __r_arr[28]; let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_77] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_78: usize = 7; const IN_78: usize = 7; const OUT_78: usize = 1; -fn aiur_fn_78(inp: [G; IN_78], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, (&__args[..]))?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { (*(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81])) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_10]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, (&__args[..]))?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { (*(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82])) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_12]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 + __v_12); let __v_14: G = (__v_3 + __v_12); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_15]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_78(inp: [G; IN_78], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_10]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_12]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = __v_2 + __v_12; let __v_14: G = __v_3 + __v_12; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_15]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_79: usize = 1; const IN_79: usize = 1; const OUT_79: usize = 64; -fn aiur_fn_79(inp: [G; IN_79], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_79] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_79(inp: [G; IN_79], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_79] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_80: usize = 2; const IN_80: usize = 2; const OUT_80: usize = 1; -fn aiur_fn_80(inp: [G; IN_80], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_80] = [__v_0]; record.function_queries[80].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, (&__args[..]))?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { (*(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80])) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_6]; record.function_queries[80].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_80(inp: [G; IN_80], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_80] = [__v_0]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, &__args[..])?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_6]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_81: usize = 6; const IN_81: usize = 6; const OUT_81: usize = 1; -fn aiur_fn_81(inp: [G; IN_81], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = __loaded[18]; let __v_38: G = __loaded[19]; let __v_39: G = __loaded[20]; let __v_40: G = __loaded[21]; let __v_41: G = __loaded[22]; let __v_42: G = __loaded[23]; let __v_43: G = __loaded[24]; let __v_44: G = __loaded[25]; let __v_45: G = __loaded[26]; let __v_46: G = __loaded[27]; let __v_47: G = __loaded[28]; let __v_48: G = __loaded[29]; let __v_49: G = __loaded[30]; let __v_50: G = __loaded[31]; let __v_51: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; let __v_55: G = __loaded[3]; let __v_56: G = __loaded[4]; let __v_57: G = __loaded[5]; let __v_58: G = __loaded[6]; let __v_59: G = __loaded[7]; let __v_60: G = G::from_u64(103); let __v_61: G = G::from_u64(230); let __v_62: G = G::from_u64(9); let __v_63: G = G::from_u64(106); let __v_64: G = G::from_u64(133); let __v_65: G = G::from_u64(174); let __v_66: G = G::from_u64(187); let __v_67: G = G::from_u64(114); let __v_68: G = G::from_u64(243); let __v_69: G = G::from_u64(110); let __v_70: G = G::from_u64(60); let __v_71: G = G::from_u64(58); let __v_72: G = G::from_u64(245); let __v_73: G = G::from_u64(79); let __v_74: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_60, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_51, __v_51, __v_51, __v_51, __v_18, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; let __v_79: G = __r_arr[4]; let __v_80: G = __r_arr[5]; let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; let __v_84: G = __r_arr[9]; let __v_85: G = __r_arr[10]; let __v_86: G = __r_arr[11]; let __v_87: G = __r_arr[12]; let __v_88: G = __r_arr[13]; let __v_89: G = __r_arr[14]; let __v_90: G = __r_arr[15]; let __v_91: G = __r_arr[16]; let __v_92: G = __r_arr[17]; let __v_93: G = __r_arr[18]; let __v_94: G = __r_arr[19]; let __v_95: G = __r_arr[20]; let __v_96: G = __r_arr[21]; let __v_97: G = __r_arr[22]; let __v_98: G = __r_arr[23]; let __v_99: G = __r_arr[24]; let __v_100: G = __r_arr[25]; let __v_101: G = __r_arr[26]; let __v_102: G = __r_arr[27]; let __v_103: G = __r_arr[28]; let __v_104: G = __r_arr[29]; let __v_105: G = __r_arr[30]; let __v_106: G = __r_arr[31]; let __v_107: G = { let __values: [G; 34] = [__v_51, __v_5, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_81] = [__v_107]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __v_28: G = __loaded[18]; let __v_29: G = __loaded[19]; let __v_30: G = __loaded[20]; let __v_31: G = __loaded[21]; let __v_32: G = __loaded[22]; let __v_33: G = __loaded[23]; let __v_34: G = __loaded[24]; let __v_35: G = __loaded[25]; let __v_36: G = __loaded[26]; let __v_37: G = __loaded[27]; let __v_38: G = __loaded[28]; let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_81] = [__v_42]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, (&__args[..]))?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { (*(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4])) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_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_80] = { let __args: [G; IN_80] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, (&__args[..]))?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { (*(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80])) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, (&__args[..]))?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { (*(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79])) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __v_33: G = __r_arr[6]; let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __v_37: G = __r_arr[10]; let __v_38: G = __r_arr[11]; let __v_39: G = __r_arr[12]; let __v_40: G = __r_arr[13]; let __v_41: G = __r_arr[14]; let __v_42: G = __r_arr[15]; let __v_43: G = __r_arr[16]; let __v_44: G = __r_arr[17]; let __v_45: G = __r_arr[18]; let __v_46: G = __r_arr[19]; let __v_47: G = __r_arr[20]; let __v_48: G = __r_arr[21]; let __v_49: G = __r_arr[22]; let __v_50: G = __r_arr[23]; let __v_51: G = __r_arr[24]; let __v_52: G = __r_arr[25]; let __v_53: G = __r_arr[26]; let __v_54: G = __r_arr[27]; let __v_55: G = __r_arr[28]; let __v_56: G = __r_arr[29]; let __v_57: G = __r_arr[30]; let __v_58: G = __r_arr[31]; let __v_59: G = __r_arr[32]; let __v_60: G = __r_arr[33]; let __v_61: G = __r_arr[34]; let __v_62: G = __r_arr[35]; let __v_63: G = __r_arr[36]; let __v_64: G = __r_arr[37]; let __v_65: G = __r_arr[38]; let __v_66: G = __r_arr[39]; let __v_67: G = __r_arr[40]; let __v_68: G = __r_arr[41]; let __v_69: G = __r_arr[42]; let __v_70: G = __r_arr[43]; let __v_71: G = __r_arr[44]; let __v_72: G = __r_arr[45]; let __v_73: G = __r_arr[46]; let __v_74: G = __r_arr[47]; let __v_75: G = __r_arr[48]; let __v_76: G = __r_arr[49]; let __v_77: G = __r_arr[50]; let __v_78: G = __r_arr[51]; let __v_79: G = __r_arr[52]; let __v_80: G = __r_arr[53]; let __v_81: G = __r_arr[54]; let __v_82: G = __r_arr[55]; let __v_83: G = __r_arr[56]; let __v_84: G = __r_arr[57]; let __v_85: G = __r_arr[58]; let __v_86: G = __r_arr[59]; let __v_87: G = __r_arr[60]; let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; let __v_94: G = __loaded[3]; let __v_95: G = __loaded[4]; let __v_96: G = __loaded[5]; let __v_97: G = __loaded[6]; let __v_98: G = __loaded[7]; let __v_99: G = __loaded[8]; let __v_100: G = __loaded[9]; let __v_101: G = __loaded[10]; let __v_102: G = __loaded[11]; let __v_103: G = __loaded[12]; let __v_104: G = __loaded[13]; let __v_105: G = __loaded[14]; let __v_106: G = __loaded[15]; let __v_107: G = __loaded[16]; let __v_108: G = __loaded[17]; let __v_109: G = __loaded[18]; let __v_110: G = __loaded[19]; let __v_111: G = __loaded[20]; let __v_112: G = __loaded[21]; let __v_113: G = __loaded[22]; let __v_114: G = __loaded[23]; let __v_115: G = __loaded[24]; let __v_116: G = __loaded[25]; let __v_117: G = __loaded[26]; let __v_118: G = __loaded[27]; let __v_119: G = __loaded[28]; let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; let __v_123: G = G::from_u64(103); let __v_124: G = G::from_u64(230); let __v_125: G = G::from_u64(9); let __v_126: G = G::from_u64(106); let __v_127: G = G::from_u64(133); let __v_128: G = G::from_u64(174); let __v_129: G = G::from_u64(187); let __v_130: G = G::from_u64(114); let __v_131: G = G::from_u64(243); let __v_132: G = G::from_u64(110); let __v_133: G = G::from_u64(60); let __v_134: G = G::from_u64(58); let __v_135: G = G::from_u64(245); let __v_136: G = G::from_u64(79); let __v_137: G = G::from_u64(165); let __v_138: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_138, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_123, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_138, __v_138, __v_138, __v_23, __v_138, __v_138, __v_138, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; let __v_141: G = __r_arr[2]; let __v_142: G = __r_arr[3]; let __v_143: G = __r_arr[4]; let __v_144: G = __r_arr[5]; let __v_145: G = __r_arr[6]; let __v_146: G = __r_arr[7]; let __v_147: G = __r_arr[8]; let __v_148: G = __r_arr[9]; let __v_149: G = __r_arr[10]; let __v_150: G = __r_arr[11]; let __v_151: G = __r_arr[12]; let __v_152: G = __r_arr[13]; let __v_153: G = __r_arr[14]; let __v_154: G = __r_arr[15]; let __v_155: G = __r_arr[16]; let __v_156: G = __r_arr[17]; let __v_157: G = __r_arr[18]; let __v_158: G = __r_arr[19]; let __v_159: G = __r_arr[20]; let __v_160: G = __r_arr[21]; let __v_161: G = __r_arr[22]; let __v_162: G = __r_arr[23]; let __v_163: G = __r_arr[24]; let __v_164: G = __r_arr[25]; let __v_165: G = __r_arr[26]; let __v_166: G = __r_arr[27]; let __v_167: G = __r_arr[28]; let __v_168: G = __r_arr[29]; let __v_169: G = __r_arr[30]; let __v_170: G = __r_arr[31]; let __v_171: G = { let __values: [G; 34] = [__v_138, __v_5, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_81] = [__v_171]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_81(inp: [G; IN_81], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = __v_6 + __v_7; let __v_18: G = __v_8 + __v_17; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = __loaded[18]; let __v_38: G = __loaded[19]; let __v_39: G = __loaded[20]; let __v_40: G = __loaded[21]; let __v_41: G = __loaded[22]; let __v_42: G = __loaded[23]; let __v_43: G = __loaded[24]; let __v_44: G = __loaded[25]; let __v_45: G = __loaded[26]; let __v_46: G = __loaded[27]; let __v_47: G = __loaded[28]; let __v_48: G = __loaded[29]; let __v_49: G = __loaded[30]; let __v_50: G = __loaded[31]; let __v_51: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; let __v_55: G = __loaded[3]; let __v_56: G = __loaded[4]; let __v_57: G = __loaded[5]; let __v_58: G = __loaded[6]; let __v_59: G = __loaded[7]; let __v_60: G = G::from_u64(103); let __v_61: G = G::from_u64(230); let __v_62: G = G::from_u64(9); let __v_63: G = G::from_u64(106); let __v_64: G = G::from_u64(133); let __v_65: G = G::from_u64(174); let __v_66: G = G::from_u64(187); let __v_67: G = G::from_u64(114); let __v_68: G = G::from_u64(243); let __v_69: G = G::from_u64(110); let __v_70: G = G::from_u64(60); let __v_71: G = G::from_u64(58); let __v_72: G = G::from_u64(245); let __v_73: G = G::from_u64(79); let __v_74: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_60, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_51, __v_51, __v_51, __v_51, __v_18, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; let __v_79: G = __r_arr[4]; let __v_80: G = __r_arr[5]; let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; let __v_84: G = __r_arr[9]; let __v_85: G = __r_arr[10]; let __v_86: G = __r_arr[11]; let __v_87: G = __r_arr[12]; let __v_88: G = __r_arr[13]; let __v_89: G = __r_arr[14]; let __v_90: G = __r_arr[15]; let __v_91: G = __r_arr[16]; let __v_92: G = __r_arr[17]; let __v_93: G = __r_arr[18]; let __v_94: G = __r_arr[19]; let __v_95: G = __r_arr[20]; let __v_96: G = __r_arr[21]; let __v_97: G = __r_arr[22]; let __v_98: G = __r_arr[23]; let __v_99: G = __r_arr[24]; let __v_100: G = __r_arr[25]; let __v_101: G = __r_arr[26]; let __v_102: G = __r_arr[27]; let __v_103: G = __r_arr[28]; let __v_104: G = __r_arr[29]; let __v_105: G = __r_arr[30]; let __v_106: G = __r_arr[31]; let __v_107: G = { let __values: [G; 34] = [__v_51, __v_5, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_81] = [__v_107]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __v_28: G = __loaded[18]; let __v_29: G = __loaded[19]; let __v_30: G = __loaded[20]; let __v_31: G = __loaded[21]; let __v_32: G = __loaded[22]; let __v_33: G = __loaded[23]; let __v_34: G = __loaded[24]; let __v_35: G = __loaded[25]; let __v_36: G = __loaded[26]; let __v_37: G = __loaded[27]; let __v_38: G = __loaded[28]; let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_81] = [__v_42]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_17 * __v_8; let __v_19: G = __v_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_80] = { let __args: [G; IN_80] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, &__args[..])?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, &__args[..])?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __v_33: G = __r_arr[6]; let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __v_37: G = __r_arr[10]; let __v_38: G = __r_arr[11]; let __v_39: G = __r_arr[12]; let __v_40: G = __r_arr[13]; let __v_41: G = __r_arr[14]; let __v_42: G = __r_arr[15]; let __v_43: G = __r_arr[16]; let __v_44: G = __r_arr[17]; let __v_45: G = __r_arr[18]; let __v_46: G = __r_arr[19]; let __v_47: G = __r_arr[20]; let __v_48: G = __r_arr[21]; let __v_49: G = __r_arr[22]; let __v_50: G = __r_arr[23]; let __v_51: G = __r_arr[24]; let __v_52: G = __r_arr[25]; let __v_53: G = __r_arr[26]; let __v_54: G = __r_arr[27]; let __v_55: G = __r_arr[28]; let __v_56: G = __r_arr[29]; let __v_57: G = __r_arr[30]; let __v_58: G = __r_arr[31]; let __v_59: G = __r_arr[32]; let __v_60: G = __r_arr[33]; let __v_61: G = __r_arr[34]; let __v_62: G = __r_arr[35]; let __v_63: G = __r_arr[36]; let __v_64: G = __r_arr[37]; let __v_65: G = __r_arr[38]; let __v_66: G = __r_arr[39]; let __v_67: G = __r_arr[40]; let __v_68: G = __r_arr[41]; let __v_69: G = __r_arr[42]; let __v_70: G = __r_arr[43]; let __v_71: G = __r_arr[44]; let __v_72: G = __r_arr[45]; let __v_73: G = __r_arr[46]; let __v_74: G = __r_arr[47]; let __v_75: G = __r_arr[48]; let __v_76: G = __r_arr[49]; let __v_77: G = __r_arr[50]; let __v_78: G = __r_arr[51]; let __v_79: G = __r_arr[52]; let __v_80: G = __r_arr[53]; let __v_81: G = __r_arr[54]; let __v_82: G = __r_arr[55]; let __v_83: G = __r_arr[56]; let __v_84: G = __r_arr[57]; let __v_85: G = __r_arr[58]; let __v_86: G = __r_arr[59]; let __v_87: G = __r_arr[60]; let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; let __v_94: G = __loaded[3]; let __v_95: G = __loaded[4]; let __v_96: G = __loaded[5]; let __v_97: G = __loaded[6]; let __v_98: G = __loaded[7]; let __v_99: G = __loaded[8]; let __v_100: G = __loaded[9]; let __v_101: G = __loaded[10]; let __v_102: G = __loaded[11]; let __v_103: G = __loaded[12]; let __v_104: G = __loaded[13]; let __v_105: G = __loaded[14]; let __v_106: G = __loaded[15]; let __v_107: G = __loaded[16]; let __v_108: G = __loaded[17]; let __v_109: G = __loaded[18]; let __v_110: G = __loaded[19]; let __v_111: G = __loaded[20]; let __v_112: G = __loaded[21]; let __v_113: G = __loaded[22]; let __v_114: G = __loaded[23]; let __v_115: G = __loaded[24]; let __v_116: G = __loaded[25]; let __v_117: G = __loaded[26]; let __v_118: G = __loaded[27]; let __v_119: G = __loaded[28]; let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; let __v_123: G = G::from_u64(103); let __v_124: G = G::from_u64(230); let __v_125: G = G::from_u64(9); let __v_126: G = G::from_u64(106); let __v_127: G = G::from_u64(133); let __v_128: G = G::from_u64(174); let __v_129: G = G::from_u64(187); let __v_130: G = G::from_u64(114); let __v_131: G = G::from_u64(243); let __v_132: G = G::from_u64(110); let __v_133: G = G::from_u64(60); let __v_134: G = G::from_u64(58); let __v_135: G = G::from_u64(245); let __v_136: G = G::from_u64(79); let __v_137: G = G::from_u64(165); let __v_138: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_138, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_123, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_138, __v_138, __v_138, __v_23, __v_138, __v_138, __v_138, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; let __v_141: G = __r_arr[2]; let __v_142: G = __r_arr[3]; let __v_143: G = __r_arr[4]; let __v_144: G = __r_arr[5]; let __v_145: G = __r_arr[6]; let __v_146: G = __r_arr[7]; let __v_147: G = __r_arr[8]; let __v_148: G = __r_arr[9]; let __v_149: G = __r_arr[10]; let __v_150: G = __r_arr[11]; let __v_151: G = __r_arr[12]; let __v_152: G = __r_arr[13]; let __v_153: G = __r_arr[14]; let __v_154: G = __r_arr[15]; let __v_155: G = __r_arr[16]; let __v_156: G = __r_arr[17]; let __v_157: G = __r_arr[18]; let __v_158: G = __r_arr[19]; let __v_159: G = __r_arr[20]; let __v_160: G = __r_arr[21]; let __v_161: G = __r_arr[22]; let __v_162: G = __r_arr[23]; let __v_163: G = __r_arr[24]; let __v_164: G = __r_arr[25]; let __v_165: G = __r_arr[26]; let __v_166: G = __r_arr[27]; let __v_167: G = __r_arr[28]; let __v_168: G = __r_arr[29]; let __v_169: G = __r_arr[30]; let __v_170: G = __r_arr[31]; let __v_171: G = { let __values: [G; 34] = [__v_138, __v_5, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_81] = [__v_171]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_82: usize = 6; const IN_82: usize = 6; const OUT_82: usize = 1; -fn aiur_fn_82(inp: [G; IN_82], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, (&__args[..]))?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { (*(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79])) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __v_18: G = __r_arr[9]; let __v_19: G = __r_arr[10]; let __v_20: G = __r_arr[11]; let __v_21: G = __r_arr[12]; let __v_22: G = __r_arr[13]; let __v_23: G = __r_arr[14]; let __v_24: G = __r_arr[15]; let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; let __v_28: G = __r_arr[19]; let __v_29: G = __r_arr[20]; let __v_30: G = __r_arr[21]; let __v_31: G = __r_arr[22]; let __v_32: G = __r_arr[23]; let __v_33: G = __r_arr[24]; let __v_34: G = __r_arr[25]; let __v_35: G = __r_arr[26]; let __v_36: G = __r_arr[27]; let __v_37: G = __r_arr[28]; let __v_38: G = __r_arr[29]; let __v_39: G = __r_arr[30]; let __v_40: G = __r_arr[31]; let __v_41: G = __r_arr[32]; let __v_42: G = __r_arr[33]; let __v_43: G = __r_arr[34]; let __v_44: G = __r_arr[35]; let __v_45: G = __r_arr[36]; let __v_46: G = __r_arr[37]; let __v_47: G = __r_arr[38]; let __v_48: G = __r_arr[39]; let __v_49: G = __r_arr[40]; let __v_50: G = __r_arr[41]; let __v_51: G = __r_arr[42]; let __v_52: G = __r_arr[43]; let __v_53: G = __r_arr[44]; let __v_54: G = __r_arr[45]; let __v_55: G = __r_arr[46]; let __v_56: G = __r_arr[47]; let __v_57: G = __r_arr[48]; let __v_58: G = __r_arr[49]; let __v_59: G = __r_arr[50]; let __v_60: G = __r_arr[51]; let __v_61: G = __r_arr[52]; let __v_62: G = __r_arr[53]; let __v_63: G = __r_arr[54]; let __v_64: G = __r_arr[55]; let __v_65: G = __r_arr[56]; let __v_66: G = __r_arr[57]; let __v_67: G = __r_arr[58]; let __v_68: G = __r_arr[59]; let __v_69: G = __r_arr[60]; let __v_70: G = __r_arr[61]; let __v_71: G = __r_arr[62]; let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { let __r_arr: [G; OUT_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_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_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, (&__args[..]))?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { (*(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4])) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); let __v_85: G = (__v_84 + __v_7); let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_117: G = __loaded[0]; let __v_118: G = __loaded[1]; let __v_119: G = __loaded[2]; let __v_120: G = __loaded[3]; let __v_121: G = __loaded[4]; let __v_122: G = __loaded[5]; let __v_123: G = __loaded[6]; let __v_124: G = __loaded[7]; let __v_125: G = __loaded[8]; let __v_126: G = __loaded[9]; let __v_127: G = __loaded[10]; let __v_128: G = __loaded[11]; let __v_129: G = __loaded[12]; let __v_130: G = __loaded[13]; let __v_131: G = __loaded[14]; let __v_132: G = __loaded[15]; let __v_133: G = __loaded[16]; let __v_134: G = __loaded[17]; let __v_135: G = __loaded[18]; let __v_136: G = __loaded[19]; let __v_137: G = __loaded[20]; let __v_138: G = __loaded[21]; let __v_139: G = __loaded[22]; let __v_140: G = __loaded[23]; let __v_141: G = __loaded[24]; let __v_142: G = __loaded[25]; let __v_143: G = __loaded[26]; let __v_144: G = __loaded[27]; let __v_145: G = __loaded[28]; let __v_146: G = __loaded[29]; let __v_147: G = __loaded[30]; let __v_148: G = __loaded[31]; let __v_149: G = G::from_u64(64); let __v_150: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_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(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; let __v_154: G = __r_arr[3]; let __v_155: G = __r_arr[4]; let __v_156: G = __r_arr[5]; let __v_157: G = __r_arr[6]; let __v_158: G = __r_arr[7]; let __v_159: G = __r_arr[8]; let __v_160: G = __r_arr[9]; let __v_161: G = __r_arr[10]; let __v_162: G = __r_arr[11]; let __v_163: G = __r_arr[12]; let __v_164: G = __r_arr[13]; let __v_165: G = __r_arr[14]; let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; let __v_169: G = __r_arr[18]; let __v_170: G = __r_arr[19]; let __v_171: G = __r_arr[20]; let __v_172: G = __r_arr[21]; let __v_173: G = __r_arr[22]; let __v_174: G = __r_arr[23]; let __v_175: G = __r_arr[24]; let __v_176: G = __r_arr[25]; let __v_177: G = __r_arr[26]; let __v_178: G = __r_arr[27]; let __v_179: G = __r_arr[28]; let __v_180: G = __r_arr[29]; let __v_181: G = __r_arr[30]; let __v_182: G = __r_arr[31]; let __v_183: G = { let __values: [G; 34] = [__v_150, __v_5, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_184: G = G::from_u64(1); let __v_185: G = { let __values: [G; 3] = [__v_184, __v_184, __v_184]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(13, (&__args[..]))?) { [G::ZERO; OUT_13] } else { let (__hash, __hit) = record.function_queries[13].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[13].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { (*(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13])) }; __ret }, _ => { aiur_fn_13::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = __r_arr[3]; let __v_190: G = __r_arr[4]; let __v_191: G = __r_arr[5]; let __v_192: G = __r_arr[6]; let __v_193: G = __r_arr[7]; let __v_194: G = { let __values: [G; 8] = [__v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_195: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_196]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { 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_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); 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_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; let __v_79: G = __loaded[3]; let __v_80: G = __loaded[4]; let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, (&__args[..]))?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { (*(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4])) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); let __v_87: G = G::from_u64(63); let __v_88: G = (__v_2 - __v_87); let __v_89: G = G::from_bool((__v_88 == G::ZERO)); let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; let __v_96: G = __loaded[3]; let __v_97: G = __loaded[4]; let __v_98: G = __loaded[5]; let __v_99: G = __loaded[6]; let __v_100: G = __loaded[7]; let __v_101: G = __loaded[8]; let __v_102: G = __loaded[9]; let __v_103: G = __loaded[10]; let __v_104: G = __loaded[11]; let __v_105: G = __loaded[12]; let __v_106: G = __loaded[13]; let __v_107: G = __loaded[14]; let __v_108: G = __loaded[15]; let __v_109: G = __loaded[16]; let __v_110: G = __loaded[17]; let __v_111: G = __loaded[18]; let __v_112: G = __loaded[19]; let __v_113: G = __loaded[20]; let __v_114: G = __loaded[21]; let __v_115: G = __loaded[22]; let __v_116: G = __loaded[23]; let __v_117: G = __loaded[24]; let __v_118: G = __loaded[25]; let __v_119: G = __loaded[26]; let __v_120: G = __loaded[27]; let __v_121: G = __loaded[28]; let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; let __v_125: G = G::from_u64(64); let __v_126: G = G::from_u64(103); let __v_127: G = G::from_u64(230); let __v_128: G = G::from_u64(9); let __v_129: G = G::from_u64(106); let __v_130: G = G::from_u64(133); let __v_131: G = G::from_u64(174); let __v_132: G = G::from_u64(187); let __v_133: G = G::from_u64(114); let __v_134: G = G::from_u64(243); let __v_135: G = G::from_u64(110); let __v_136: G = G::from_u64(60); let __v_137: G = G::from_u64(58); let __v_138: G = G::from_u64(245); let __v_139: G = G::from_u64(79); let __v_140: G = G::from_u64(165); let __v_141: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_141, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_126, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_125, __v_141, __v_141, __v_141, __v_92, __v_141, __v_141, __v_141, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __v_152: G = __r_arr[10]; let __v_153: G = __r_arr[11]; let __v_154: G = __r_arr[12]; let __v_155: G = __r_arr[13]; let __v_156: G = __r_arr[14]; let __v_157: G = __r_arr[15]; let __v_158: G = __r_arr[16]; let __v_159: G = __r_arr[17]; let __v_160: G = __r_arr[18]; let __v_161: G = __r_arr[19]; let __v_162: G = __r_arr[20]; let __v_163: G = __r_arr[21]; let __v_164: G = __r_arr[22]; let __v_165: G = __r_arr[23]; let __v_166: G = __r_arr[24]; let __v_167: G = __r_arr[25]; let __v_168: G = __r_arr[26]; let __v_169: G = __r_arr[27]; let __v_170: G = __r_arr[28]; let __v_171: G = __r_arr[29]; let __v_172: G = __r_arr[30]; let __v_173: G = __r_arr[31]; let __v_174: G = G::from_u64(1); let __v_175: G = { let __values: [G; 3] = [__v_174, __v_174, __v_174]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_176: G = (__v_2 + __v_174); let __v_177: G = { let __values: [G; 32] = [__v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_178]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_82(inp: [G; IN_82], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, &__args[..])?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __v_18: G = __r_arr[9]; let __v_19: G = __r_arr[10]; let __v_20: G = __r_arr[11]; let __v_21: G = __r_arr[12]; let __v_22: G = __r_arr[13]; let __v_23: G = __r_arr[14]; let __v_24: G = __r_arr[15]; let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; let __v_28: G = __r_arr[19]; let __v_29: G = __r_arr[20]; let __v_30: G = __r_arr[21]; let __v_31: G = __r_arr[22]; let __v_32: G = __r_arr[23]; let __v_33: G = __r_arr[24]; let __v_34: G = __r_arr[25]; let __v_35: G = __r_arr[26]; let __v_36: G = __r_arr[27]; let __v_37: G = __r_arr[28]; let __v_38: G = __r_arr[29]; let __v_39: G = __r_arr[30]; let __v_40: G = __r_arr[31]; let __v_41: G = __r_arr[32]; let __v_42: G = __r_arr[33]; let __v_43: G = __r_arr[34]; let __v_44: G = __r_arr[35]; let __v_45: G = __r_arr[36]; let __v_46: G = __r_arr[37]; let __v_47: G = __r_arr[38]; let __v_48: G = __r_arr[39]; let __v_49: G = __r_arr[40]; let __v_50: G = __r_arr[41]; let __v_51: G = __r_arr[42]; let __v_52: G = __r_arr[43]; let __v_53: G = __r_arr[44]; let __v_54: G = __r_arr[45]; let __v_55: G = __r_arr[46]; let __v_56: G = __r_arr[47]; let __v_57: G = __r_arr[48]; let __v_58: G = __r_arr[49]; let __v_59: G = __r_arr[50]; let __v_60: G = __r_arr[51]; let __v_61: G = __r_arr[52]; let __v_62: G = __r_arr[53]; let __v_63: G = __r_arr[54]; let __v_64: G = __r_arr[55]; let __v_65: G = __r_arr[56]; let __v_66: G = __r_arr[57]; let __v_67: G = __r_arr[58]; let __v_68: G = __r_arr[59]; let __v_69: G = __r_arr[60]; let __v_70: G = __r_arr[61]; let __v_71: G = __r_arr[62]; let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { let __r_arr: [G; OUT_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_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_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __v_73 * __v_82; let __v_84: G = __v_8 * __v_83; let __v_85: G = __v_84 + __v_7; let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_117: G = __loaded[0]; let __v_118: G = __loaded[1]; let __v_119: G = __loaded[2]; let __v_120: G = __loaded[3]; let __v_121: G = __loaded[4]; let __v_122: G = __loaded[5]; let __v_123: G = __loaded[6]; let __v_124: G = __loaded[7]; let __v_125: G = __loaded[8]; let __v_126: G = __loaded[9]; let __v_127: G = __loaded[10]; let __v_128: G = __loaded[11]; let __v_129: G = __loaded[12]; let __v_130: G = __loaded[13]; let __v_131: G = __loaded[14]; let __v_132: G = __loaded[15]; let __v_133: G = __loaded[16]; let __v_134: G = __loaded[17]; let __v_135: G = __loaded[18]; let __v_136: G = __loaded[19]; let __v_137: G = __loaded[20]; let __v_138: G = __loaded[21]; let __v_139: G = __loaded[22]; let __v_140: G = __loaded[23]; let __v_141: G = __loaded[24]; let __v_142: G = __loaded[25]; let __v_143: G = __loaded[26]; let __v_144: G = __loaded[27]; let __v_145: G = __loaded[28]; let __v_146: G = __loaded[29]; let __v_147: G = __loaded[30]; let __v_148: G = __loaded[31]; let __v_149: G = G::from_u64(64); let __v_150: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_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(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; let __v_154: G = __r_arr[3]; let __v_155: G = __r_arr[4]; let __v_156: G = __r_arr[5]; let __v_157: G = __r_arr[6]; let __v_158: G = __r_arr[7]; let __v_159: G = __r_arr[8]; let __v_160: G = __r_arr[9]; let __v_161: G = __r_arr[10]; let __v_162: G = __r_arr[11]; let __v_163: G = __r_arr[12]; let __v_164: G = __r_arr[13]; let __v_165: G = __r_arr[14]; let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; let __v_169: G = __r_arr[18]; let __v_170: G = __r_arr[19]; let __v_171: G = __r_arr[20]; let __v_172: G = __r_arr[21]; let __v_173: G = __r_arr[22]; let __v_174: G = __r_arr[23]; let __v_175: G = __r_arr[24]; let __v_176: G = __r_arr[25]; let __v_177: G = __r_arr[26]; let __v_178: G = __r_arr[27]; let __v_179: G = __r_arr[28]; let __v_180: G = __r_arr[29]; let __v_181: G = __r_arr[30]; let __v_182: G = __r_arr[31]; let __v_183: G = { let __values: [G; 34] = [__v_150, __v_5, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_184: G = G::from_u64(1); let __v_185: G = { let __values: [G; 3] = [__v_184, __v_184, __v_184]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(13, &__args[..])?) { [G::ZERO; OUT_13] } else { let (__hash, __hit) = record.function_queries[13].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[13].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => { aiur_fn_13::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = __r_arr[3]; let __v_190: G = __r_arr[4]; let __v_191: G = __r_arr[5]; let __v_192: G = __r_arr[6]; let __v_193: G = __r_arr[7]; let __v_194: G = { let __values: [G; 8] = [__v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_195: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_196]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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_73: G = __r_arr[0]; let __v_74: G = __v_73 * __v_7; 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_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; let __v_79: G = __loaded[3]; let __v_80: G = __loaded[4]; let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __v_84 * __v_8; let __v_86: G = __v_75 * __v_85; let __v_87: G = G::from_u64(63); let __v_88: G = __v_2 - __v_87; let __v_89: G = G::from_bool(__v_88 == G::ZERO); let __v_90: G = __v_89 * __v_6; let __v_91: G = __v_86 + __v_90; let __v_92: G = __v_74 + __v_91; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; let __v_96: G = __loaded[3]; let __v_97: G = __loaded[4]; let __v_98: G = __loaded[5]; let __v_99: G = __loaded[6]; let __v_100: G = __loaded[7]; let __v_101: G = __loaded[8]; let __v_102: G = __loaded[9]; let __v_103: G = __loaded[10]; let __v_104: G = __loaded[11]; let __v_105: G = __loaded[12]; let __v_106: G = __loaded[13]; let __v_107: G = __loaded[14]; let __v_108: G = __loaded[15]; let __v_109: G = __loaded[16]; let __v_110: G = __loaded[17]; let __v_111: G = __loaded[18]; let __v_112: G = __loaded[19]; let __v_113: G = __loaded[20]; let __v_114: G = __loaded[21]; let __v_115: G = __loaded[22]; let __v_116: G = __loaded[23]; let __v_117: G = __loaded[24]; let __v_118: G = __loaded[25]; let __v_119: G = __loaded[26]; let __v_120: G = __loaded[27]; let __v_121: G = __loaded[28]; let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; let __v_125: G = G::from_u64(64); let __v_126: G = G::from_u64(103); let __v_127: G = G::from_u64(230); let __v_128: G = G::from_u64(9); let __v_129: G = G::from_u64(106); let __v_130: G = G::from_u64(133); let __v_131: G = G::from_u64(174); let __v_132: G = G::from_u64(187); let __v_133: G = G::from_u64(114); let __v_134: G = G::from_u64(243); let __v_135: G = G::from_u64(110); let __v_136: G = G::from_u64(60); let __v_137: G = G::from_u64(58); let __v_138: G = G::from_u64(245); let __v_139: G = G::from_u64(79); let __v_140: G = G::from_u64(165); let __v_141: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_141, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_126, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_125, __v_141, __v_141, __v_141, __v_92, __v_141, __v_141, __v_141, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __v_152: G = __r_arr[10]; let __v_153: G = __r_arr[11]; let __v_154: G = __r_arr[12]; let __v_155: G = __r_arr[13]; let __v_156: G = __r_arr[14]; let __v_157: G = __r_arr[15]; let __v_158: G = __r_arr[16]; let __v_159: G = __r_arr[17]; let __v_160: G = __r_arr[18]; let __v_161: G = __r_arr[19]; let __v_162: G = __r_arr[20]; let __v_163: G = __r_arr[21]; let __v_164: G = __r_arr[22]; let __v_165: G = __r_arr[23]; let __v_166: G = __r_arr[24]; let __v_167: G = __r_arr[25]; let __v_168: G = __r_arr[26]; let __v_169: G = __r_arr[27]; let __v_170: G = __r_arr[28]; let __v_171: G = __r_arr[29]; let __v_172: G = __r_arr[30]; let __v_173: G = __r_arr[31]; let __v_174: G = G::from_u64(1); let __v_175: G = { let __values: [G; 3] = [__v_174, __v_174, __v_174]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_176: G = __v_2 + __v_174; let __v_177: G = { let __values: [G; 32] = [__v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_178]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_83: usize = 24; const IN_83: usize = 24; const OUT_83: usize = 16; -fn aiur_fn_83(inp: [G; IN_83], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = 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_83] = [__v_58, __v_59, __v_60, __v_61, __v_85, __v_86, __v_87, __v_88, __v_71, __v_72, __v_73, __v_74, __v_68, __v_69, __v_70, __v_67]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_83(inp: [G; IN_83], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __u32_sum: u128 = (u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24))) + u128::from((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_29: G = G::from_u64(1); let __v_30: G = __v_28 - __v_29; let __v_31: G = 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_83] = [__v_58, __v_59, __v_60, __v_61, __v_85, __v_86, __v_87, __v_88, __v_71, __v_72, __v_73, __v_74, __v_68, __v_69, __v_70, __v_67]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_84: usize = 128; const IN_84: usize = 128; const OUT_84: usize = 128; -fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))) + u128::from(((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = 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_84] = [__v_410, __v_411, __v_412, __v_413, __v_472, __v_473, __v_474, __v_475, __v_534, __v_535, __v_536, __v_537, __v_596, __v_597, __v_598, __v_599, __v_623, __v_624, __v_625, __v_626, __v_437, __v_438, __v_439, __v_440, __v_499, __v_500, __v_501, __v_502, __v_561, __v_562, __v_563, __v_564, __v_547, __v_548, __v_549, __v_550, __v_609, __v_610, __v_611, __v_612, __v_423, __v_424, __v_425, __v_426, __v_485, __v_486, __v_487, __v_488, __v_482, __v_483, __v_484, __v_481, __v_544, __v_545, __v_546, __v_543, __v_606, __v_607, __v_608, __v_605, __v_420, __v_421, __v_422, __v_419, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; record.function_queries[84].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __u32_sum: u128 = (u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24))) + u128::from((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_133: G = G::from_u64(1); let __v_134: G = __v_132 - __v_133; let __v_135: G = 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_84] = [__v_410, __v_411, __v_412, __v_413, __v_472, __v_473, __v_474, __v_475, __v_534, __v_535, __v_536, __v_537, __v_596, __v_597, __v_598, __v_599, __v_623, __v_624, __v_625, __v_626, __v_437, __v_438, __v_439, __v_440, __v_499, __v_500, __v_501, __v_502, __v_561, __v_562, __v_563, __v_564, __v_547, __v_548, __v_549, __v_550, __v_609, __v_610, __v_611, __v_612, __v_423, __v_424, __v_425, __v_426, __v_485, __v_486, __v_487, __v_488, __v_482, __v_483, __v_484, __v_481, __v_544, __v_545, __v_546, __v_543, __v_606, __v_607, __v_608, __v_605, __v_420, __v_421, __v_422, __v_419, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_85: usize = 106; const IN_85: usize = 106; const OUT_85: usize = 32; -fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); let __v_109: G = G::from_u64(106); let __v_110: G = G::from_u64(133); let __v_111: G = G::from_u64(174); let __v_112: G = G::from_u64(187); let __v_113: G = G::from_u64(114); let __v_114: G = G::from_u64(243); let __v_115: G = G::from_u64(110); let __v_116: G = G::from_u64(60); let __v_117: G = G::from_u64(58); let __v_118: G = G::from_u64(245); let __v_119: G = G::from_u64(79); let __v_120: G = G::from_u64(165); let __v_121: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_121, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_106, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_121, __v_121, __v_121, __v_105, __v_121, __v_121, __v_121, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; let __v_125: G = __r_arr[3]; let __v_126: G = __r_arr[4]; let __v_127: G = __r_arr[5]; let __v_128: G = __r_arr[6]; let __v_129: G = __r_arr[7]; let __v_130: G = __r_arr[8]; let __v_131: G = __r_arr[9]; let __v_132: G = __r_arr[10]; let __v_133: G = __r_arr[11]; let __v_134: G = __r_arr[12]; let __v_135: G = __r_arr[13]; let __v_136: G = __r_arr[14]; let __v_137: G = __r_arr[15]; let __v_138: G = __r_arr[16]; let __v_139: G = __r_arr[17]; let __v_140: G = __r_arr[18]; let __v_141: G = __r_arr[19]; let __v_142: G = __r_arr[20]; let __v_143: G = __r_arr[21]; let __v_144: G = __r_arr[22]; let __v_145: G = __r_arr[23]; let __v_146: G = __r_arr[24]; let __v_147: G = __r_arr[25]; let __v_148: G = __r_arr[26]; let __v_149: G = __r_arr[27]; let __v_150: G = __r_arr[28]; let __v_151: G = __r_arr[29]; let __v_152: G = __r_arr[30]; let __v_153: G = __r_arr[31]; let __ret: [G; OUT_85] = [__v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153]; record.function_queries[85].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); let __v_109: G = G::from_u64(106); let __v_110: G = G::from_u64(133); let __v_111: G = G::from_u64(174); let __v_112: G = G::from_u64(187); let __v_113: G = G::from_u64(114); let __v_114: G = G::from_u64(243); let __v_115: G = G::from_u64(110); let __v_116: G = G::from_u64(60); let __v_117: G = G::from_u64(58); let __v_118: G = G::from_u64(245); let __v_119: G = G::from_u64(79); let __v_120: G = G::from_u64(165); let __v_121: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_121, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_106, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_121, __v_121, __v_121, __v_105, __v_121, __v_121, __v_121, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; let __v_125: G = __r_arr[3]; let __v_126: G = __r_arr[4]; let __v_127: G = __r_arr[5]; let __v_128: G = __r_arr[6]; let __v_129: G = __r_arr[7]; let __v_130: G = __r_arr[8]; let __v_131: G = __r_arr[9]; let __v_132: G = __r_arr[10]; let __v_133: G = __r_arr[11]; let __v_134: G = __r_arr[12]; let __v_135: G = __r_arr[13]; let __v_136: G = __r_arr[14]; let __v_137: G = __r_arr[15]; let __v_138: G = __r_arr[16]; let __v_139: G = __r_arr[17]; let __v_140: G = __r_arr[18]; let __v_141: G = __r_arr[19]; let __v_142: G = __r_arr[20]; let __v_143: G = __r_arr[21]; let __v_144: G = __r_arr[22]; let __v_145: G = __r_arr[23]; let __v_146: G = __r_arr[24]; let __v_147: G = __r_arr[25]; let __v_148: G = __r_arr[26]; let __v_149: G = __r_arr[27]; let __v_150: G = __r_arr[28]; let __v_151: G = __r_arr[29]; let __v_152: G = __r_arr[30]; let __v_153: G = __r_arr[31]; let __ret: [G; OUT_85] = [__v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153]; record.function_queries[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_86: usize = 129; const IN_86: usize = 129; const OUT_86: usize = 32; -fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __v_128: G = inp[128]; match __v_0.as_canonical_u64() { 7u64 => { let __v_129: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_1), (&__v_33)) } else { aiur::execute::bytes2_xor_value(__v_1, __v_33, record) }; let __v_130: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_2), (&__v_34)) } else { aiur::execute::bytes2_xor_value(__v_2, __v_34, record) }; let __v_131: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_3), (&__v_35)) } else { aiur::execute::bytes2_xor_value(__v_3, __v_35, record) }; let __v_132: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_4), (&__v_36)) } else { aiur::execute::bytes2_xor_value(__v_4, __v_36, record) }; let __v_133: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_5), (&__v_37)) } else { aiur::execute::bytes2_xor_value(__v_5, __v_37, record) }; let __v_134: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_6), (&__v_38)) } else { aiur::execute::bytes2_xor_value(__v_6, __v_38, record) }; let __v_135: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_7), (&__v_39)) } else { aiur::execute::bytes2_xor_value(__v_7, __v_39, record) }; let __v_136: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_8), (&__v_40)) } else { aiur::execute::bytes2_xor_value(__v_8, __v_40, record) }; let __v_137: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_9), (&__v_41)) } else { aiur::execute::bytes2_xor_value(__v_9, __v_41, record) }; let __v_138: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_10), (&__v_42)) } else { aiur::execute::bytes2_xor_value(__v_10, __v_42, record) }; let __v_139: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_11), (&__v_43)) } else { aiur::execute::bytes2_xor_value(__v_11, __v_43, record) }; let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_44)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_44, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_45)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_45, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_46)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_46, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_47)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_47, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_16), (&__v_48)) } else { aiur::execute::bytes2_xor_value(__v_16, __v_48, record) }; let __v_145: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_17), (&__v_49)) } else { aiur::execute::bytes2_xor_value(__v_17, __v_49, record) }; let __v_146: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_18), (&__v_50)) } else { aiur::execute::bytes2_xor_value(__v_18, __v_50, record) }; let __v_147: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_19), (&__v_51)) } else { aiur::execute::bytes2_xor_value(__v_19, __v_51, record) }; let __v_148: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_20), (&__v_52)) } else { aiur::execute::bytes2_xor_value(__v_20, __v_52, record) }; let __v_149: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_21), (&__v_53)) } else { aiur::execute::bytes2_xor_value(__v_21, __v_53, record) }; let __v_150: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_22), (&__v_54)) } else { aiur::execute::bytes2_xor_value(__v_22, __v_54, record) }; let __v_151: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_23), (&__v_55)) } else { aiur::execute::bytes2_xor_value(__v_23, __v_55, record) }; let __v_152: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_24), (&__v_56)) } else { aiur::execute::bytes2_xor_value(__v_24, __v_56, record) }; let __v_153: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_25), (&__v_57)) } else { aiur::execute::bytes2_xor_value(__v_25, __v_57, record) }; let __v_154: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_26), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_26, __v_58, record) }; let __v_155: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_27), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_27, __v_59, record) }; let __v_156: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_28), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_28, __v_60, record) }; let __v_157: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_29), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_29, __v_61, record) }; let __v_158: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_30), (&__v_62)) } else { aiur::execute::bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_31), (&__v_63)) } else { aiur::execute::bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_32), (&__v_64)) } else { aiur::execute::bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_86] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = ((u128::from(((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24))) + u128::from(((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24)))) + u128::from(((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = 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_86] = { let __args: [G; IN_86] = [__v_628, __v_411, __v_412, __v_413, __v_414, __v_473, __v_474, __v_475, __v_476, __v_535, __v_536, __v_537, __v_538, __v_597, __v_598, __v_599, __v_600, __v_624, __v_625, __v_626, __v_627, __v_438, __v_439, __v_440, __v_441, __v_500, __v_501, __v_502, __v_503, __v_562, __v_563, __v_564, __v_565, __v_548, __v_549, __v_550, __v_551, __v_610, __v_611, __v_612, __v_613, __v_424, __v_425, __v_426, __v_427, __v_486, __v_487, __v_488, __v_489, __v_483, __v_484, __v_485, __v_482, __v_545, __v_546, __v_547, __v_544, __v_607, __v_608, __v_609, __v_606, __v_421, __v_422, __v_423, __v_420, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_629: G = __r_arr[0]; let __v_630: G = __r_arr[1]; let __v_631: G = __r_arr[2]; let __v_632: G = __r_arr[3]; let __v_633: G = __r_arr[4]; let __v_634: G = __r_arr[5]; let __v_635: G = __r_arr[6]; let __v_636: G = __r_arr[7]; let __v_637: G = __r_arr[8]; let __v_638: G = __r_arr[9]; let __v_639: G = __r_arr[10]; let __v_640: G = __r_arr[11]; let __v_641: G = __r_arr[12]; let __v_642: G = __r_arr[13]; let __v_643: G = __r_arr[14]; let __v_644: G = __r_arr[15]; let __v_645: G = __r_arr[16]; let __v_646: G = __r_arr[17]; let __v_647: G = __r_arr[18]; let __v_648: G = __r_arr[19]; let __v_649: G = __r_arr[20]; let __v_650: G = __r_arr[21]; let __v_651: G = __r_arr[22]; let __v_652: G = __r_arr[23]; let __v_653: G = __r_arr[24]; let __v_654: G = __r_arr[25]; let __v_655: G = __r_arr[26]; let __v_656: G = __r_arr[27]; let __v_657: G = __r_arr[28]; let __v_658: G = __r_arr[29]; let __v_659: G = __r_arr[30]; let __v_660: G = __r_arr[31]; let __ret: [G; OUT_86] = [__v_629, __v_630, __v_631, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __v_128: G = inp[128]; match __v_0.as_canonical_u64() { 7u64 => { let __v_129: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_33) } else { aiur::execute::bytes2_xor_value(__v_1, __v_33, record) }; let __v_130: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_34) } else { aiur::execute::bytes2_xor_value(__v_2, __v_34, record) }; let __v_131: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_35) } else { aiur::execute::bytes2_xor_value(__v_3, __v_35, record) }; let __v_132: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_4, &__v_36) } else { aiur::execute::bytes2_xor_value(__v_4, __v_36, record) }; let __v_133: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_5, &__v_37) } else { aiur::execute::bytes2_xor_value(__v_5, __v_37, record) }; let __v_134: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_6, &__v_38) } else { aiur::execute::bytes2_xor_value(__v_6, __v_38, record) }; let __v_135: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_7, &__v_39) } else { aiur::execute::bytes2_xor_value(__v_7, __v_39, record) }; let __v_136: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_8, &__v_40) } else { aiur::execute::bytes2_xor_value(__v_8, __v_40, record) }; let __v_137: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_9, &__v_41) } else { aiur::execute::bytes2_xor_value(__v_9, __v_41, record) }; let __v_138: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_10, &__v_42) } else { aiur::execute::bytes2_xor_value(__v_10, __v_42, record) }; let __v_139: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_11, &__v_43) } else { aiur::execute::bytes2_xor_value(__v_11, __v_43, record) }; let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_12, &__v_44) } else { aiur::execute::bytes2_xor_value(__v_12, __v_44, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_13, &__v_45) } else { aiur::execute::bytes2_xor_value(__v_13, __v_45, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_14, &__v_46) } else { aiur::execute::bytes2_xor_value(__v_14, __v_46, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_15, &__v_47) } else { aiur::execute::bytes2_xor_value(__v_15, __v_47, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_16, &__v_48) } else { aiur::execute::bytes2_xor_value(__v_16, __v_48, record) }; let __v_145: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_17, &__v_49) } else { aiur::execute::bytes2_xor_value(__v_17, __v_49, record) }; let __v_146: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_18, &__v_50) } else { aiur::execute::bytes2_xor_value(__v_18, __v_50, record) }; let __v_147: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_19, &__v_51) } else { aiur::execute::bytes2_xor_value(__v_19, __v_51, record) }; let __v_148: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_20, &__v_52) } else { aiur::execute::bytes2_xor_value(__v_20, __v_52, record) }; let __v_149: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_21, &__v_53) } else { aiur::execute::bytes2_xor_value(__v_21, __v_53, record) }; let __v_150: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_22, &__v_54) } else { aiur::execute::bytes2_xor_value(__v_22, __v_54, record) }; let __v_151: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_23, &__v_55) } else { aiur::execute::bytes2_xor_value(__v_23, __v_55, record) }; let __v_152: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_24, &__v_56) } else { aiur::execute::bytes2_xor_value(__v_24, __v_56, record) }; let __v_153: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_25, &__v_57) } else { aiur::execute::bytes2_xor_value(__v_25, __v_57, record) }; let __v_154: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_26, &__v_58) } else { aiur::execute::bytes2_xor_value(__v_26, __v_58, record) }; let __v_155: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_27, &__v_59) } else { aiur::execute::bytes2_xor_value(__v_27, __v_59, record) }; let __v_156: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_28, &__v_60) } else { aiur::execute::bytes2_xor_value(__v_28, __v_60, record) }; let __v_157: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_29, &__v_61) } else { aiur::execute::bytes2_xor_value(__v_29, __v_61, record) }; let __v_158: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_30, &__v_62) } else { aiur::execute::bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_31, &__v_63) } else { aiur::execute::bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_32, &__v_64) } else { aiur::execute::bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_86] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; record.function_queries[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = (u128::from((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24)) + u128::from((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24))) + u128::from((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_134: G = G::from_u64(1); let __v_135: G = __v_133 - __v_134; let __v_136: G = 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_86] = { let __args: [G; IN_86] = [__v_628, __v_411, __v_412, __v_413, __v_414, __v_473, __v_474, __v_475, __v_476, __v_535, __v_536, __v_537, __v_538, __v_597, __v_598, __v_599, __v_600, __v_624, __v_625, __v_626, __v_627, __v_438, __v_439, __v_440, __v_441, __v_500, __v_501, __v_502, __v_503, __v_562, __v_563, __v_564, __v_565, __v_548, __v_549, __v_550, __v_551, __v_610, __v_611, __v_612, __v_613, __v_424, __v_425, __v_426, __v_427, __v_486, __v_487, __v_488, __v_489, __v_483, __v_484, __v_485, __v_482, __v_545, __v_546, __v_547, __v_544, __v_607, __v_608, __v_609, __v_606, __v_421, __v_422, __v_423, __v_420, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_629: G = __r_arr[0]; let __v_630: G = __r_arr[1]; let __v_631: G = __r_arr[2]; let __v_632: G = __r_arr[3]; let __v_633: G = __r_arr[4]; let __v_634: G = __r_arr[5]; let __v_635: G = __r_arr[6]; let __v_636: G = __r_arr[7]; let __v_637: G = __r_arr[8]; let __v_638: G = __r_arr[9]; let __v_639: G = __r_arr[10]; let __v_640: G = __r_arr[11]; let __v_641: G = __r_arr[12]; let __v_642: G = __r_arr[13]; let __v_643: G = __r_arr[14]; let __v_644: G = __r_arr[15]; let __v_645: G = __r_arr[16]; let __v_646: G = __r_arr[17]; let __v_647: G = __r_arr[18]; let __v_648: G = __r_arr[19]; let __v_649: G = __r_arr[20]; let __v_650: G = __r_arr[21]; let __v_651: G = __r_arr[22]; let __v_652: G = __r_arr[23]; let __v_653: G = __r_arr[24]; let __v_654: G = __r_arr[25]; let __v_655: G = __r_arr[26]; let __v_656: G = __r_arr[27]; let __v_657: G = __r_arr[28]; let __v_658: G = __r_arr[29]; let __v_659: G = __r_arr[30]; let __v_660: G = __r_arr[31]; let __ret: [G; OUT_86] = [__v_629, __v_630, __v_631, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660]; record.function_queries[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_87: usize = 1; const IN_87: usize = 1; const OUT_87: usize = 2; -fn aiur_fn_87(inp: [G; IN_87], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_87] = [__v_2, __v_3]; record.function_queries[87].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_87(inp: [G; IN_87], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_87] = [__v_2, __v_3]; record.function_queries[87].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_88: usize = 1; const IN_88: usize = 1; const OUT_88: usize = 2; -fn aiur_fn_88(inp: [G; IN_88], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_88(inp: [G; IN_88], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_88] = [__v_1, __v_2]; record.function_queries[88].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_89: usize = 1; const IN_89: usize = 1; const OUT_89: usize = 2; -fn aiur_fn_89(inp: [G; IN_89], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __ret: [G; OUT_89] = [__v_7, __v_4]; record.function_queries[89].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_89(inp: [G; IN_89], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = __v_5 * __v_3; let __v_7: G = __v_1 + __v_6; let __ret: [G; OUT_89] = [__v_7, __v_4]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_90: usize = 1; const IN_90: usize = 1; const OUT_90: usize = 10; -fn aiur_fn_90(inp: [G; IN_90], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_90] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[90].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_90(inp: [G; IN_90], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = __v_5 * __v_3; let __v_7: G = __v_1 + __v_6; let __v_8: G = G::from_u64(0); let __ret: [G; OUT_90] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[90].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_91: usize = 1; const IN_91: usize = 1; const OUT_91: usize = 10; -fn aiur_fn_91(inp: [G; IN_91], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_3); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_5); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_7); let __v_15: G = (__v_12 + __v_14); let __v_16: G = (__v_10 + __v_15); let __v_17: G = (__v_1 + __v_16); let __v_18: G = G::from_u64(0); let __ret: [G; OUT_91] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[91].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_91(inp: [G; IN_91], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_3; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_5; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_7; let __v_15: G = __v_12 + __v_14; let __v_16: G = __v_10 + __v_15; let __v_17: G = __v_1 + __v_16; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_91] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_92: usize = 1; const IN_92: usize = 1; const OUT_92: usize = 9; -fn aiur_fn_92(inp: [G; IN_92], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_92(inp: [G; IN_92], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_93: usize = 1; const IN_93: usize = 1; const OUT_93: usize = 2; -fn aiur_fn_93(inp: [G; IN_93], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_2); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_3); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_4); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_5); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_6); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_7); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_8); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_1 + __v_29); let __ret: [G; OUT_93] = [__v_30, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_93(inp: [G; IN_93], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_2; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_3; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_4; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_5; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_6; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_7; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_8; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_1 + __v_29; let __ret: [G; OUT_93] = [__v_30, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_94: usize = 1; const IN_94: usize = 1; const OUT_94: usize = 33; -fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_94] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_94] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[94].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_95: usize = 2; const IN_95: usize = 2; const OUT_95: usize = 2; -fn aiur_fn_95(inp: [G; IN_95], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_95] = [__v_3, __v_0]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, (&__args[..]))?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { (*(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95])) }; __ret }, _ => { aiur_fn_95::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_95] = [__v_44, __v_41]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_95(inp: [G; IN_95], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_95] = [__v_3, __v_0]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_95] = [__v_44, __v_41]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_96: usize = 3; const IN_96: usize = 3; const OUT_96: usize = 2; -fn aiur_fn_96(inp: [G; IN_96], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 6] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_4, __v_0]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(3); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(4); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(6); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(7); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_2 + __v_8); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(9); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_5, __v_13, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_15, __v_12]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_96(inp: [G; IN_96], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 6] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_4, __v_0]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(3); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(4); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(6); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(7); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_9: G = __v_1 - __v_8; let __v_10: G = __v_2 + __v_8; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(9); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_5, __v_13, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_15, __v_12]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_97: usize = 2; const IN_97: usize = 2; const OUT_97: usize = 2; -fn aiur_fn_97(inp: [G; IN_97], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_97] = [__v_3, __v_0]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_97] = [__v_9, __v_7]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_97(inp: [G; IN_97], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_97] = [__v_3, __v_0]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_97] = [__v_9, __v_7]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_98: usize = 1; const IN_98: usize = 1; const OUT_98: usize = 3; -fn aiur_fn_98(inp: [G; IN_98], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_1, __v_5, __v_6]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_98(inp: [G; IN_98], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_1, __v_5, __v_6]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_99: usize = 2; const IN_99: usize = 2; const OUT_99: usize = 2; -fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_3, __v_0]; record.function_queries[99].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, (&__args[..]))?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { (*(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99])) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_3, __v_0]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_100: usize = 3; const IN_100: usize = 3; const OUT_100: usize = 1; -fn aiur_fn_100(inp: [G; IN_100], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_100] = [__v_3]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 - __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_3 + __v_6); let __ret: [G; OUT_100] = [__v_7]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 - __v_3); let __v_5: G = (__v_1 - __v_3); let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_100] = [__v_6]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_100(inp: [G; IN_100], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_100] = [__v_3]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 - __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_100] = [__v_7]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 - __v_3; let __v_5: G = __v_1 - __v_3; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_100] = [__v_6]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_101: usize = 1; const IN_101: usize = 1; const OUT_101: usize = 66; -fn aiur_fn_101(inp: [G; IN_101], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, (&__args[..]))?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { (*(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91])) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_49, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, (&__args[..]))?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { (*(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99])) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool((__v_56 == G::ZERO)); let __v_58: G = (__v_56 + __v_57); let __v_59: G = (__v_58 + __v_58); let __v_60: G = (__v_48 + __v_59); let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_61: G = G::from_u8(__gb[0]); let __v_62: G = G::from_u8(__gb[1]); let __v_63: G = G::from_u8(__gb[2]); let __v_64: G = G::from_u8(__gb[3]); let __v_65: G = G::from_u8(__gb[4]); let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_69: G = G::from_u64(256); let __v_70: G = (__v_69 * __v_62); let __v_71: G = G::from_u64(65536); let __v_72: G = (__v_71 * __v_63); let __v_73: G = G::from_u64(16777216); let __v_74: G = (__v_73 * __v_64); let __v_75: G = G::from_u64(4294967296); let __v_76: G = (__v_75 * __v_65); let __v_77: G = G::from_u64(1099511627776); let __v_78: G = (__v_77 * __v_66); let __v_79: G = G::from_u64(281474976710656); let __v_80: G = (__v_79 * __v_67); let __v_81: G = G::from_u64(72057594037927936); let __v_82: G = (__v_81 * __v_68); let __v_83: G = (__v_80 + __v_82); let __v_84: G = (__v_78 + __v_83); let __v_85: G = (__v_76 + __v_84); let __v_86: G = (__v_74 + __v_85); let __v_87: G = (__v_72 + __v_86); let __v_88: G = (__v_70 + __v_87); let __v_89: G = (__v_61 + __v_88); if (__v_89 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_90: G = G::from_u64(1020); let __v_91: G = (__v_68 - __v_90); let __v_92: G = (__v_67 + __v_91); let __v_93: G = (__v_66 + __v_92); let __v_94: G = (__v_65 + __v_93); let __v_95: G = G::from_bool((__v_94 == G::ZERO)); let __v_96: G = (__v_63 + __v_64); let __v_97: G = (__v_62 + __v_96); let __v_98: G = (__v_61 + __v_97); let __v_99: G = G::from_bool((__v_98 == G::ZERO)); let __v_100: G = G::from_u64(1); let __v_101: G = (__v_100 - __v_99); let __v_102: G = (__v_95 * __v_101); let __v_103: G = (__v_100 - __v_102); if (__v_103 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_59.as_canonical_u64().to_le_bytes(); let __v_104: G = G::from_u8(__gb[0]); let __v_105: G = G::from_u8(__gb[1]); let __v_106: G = G::from_u8(__gb[2]); let __v_107: G = G::from_u8(__gb[3]); let __v_108: G = G::from_u8(__gb[4]); let __v_109: G = G::from_u8(__gb[5]); let __v_110: G = G::from_u8(__gb[6]); let __v_111: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_104; let __vj = __v_105; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_106; let __vj = __v_107; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_112: G = (__v_69 * __v_105); let __v_113: G = (__v_71 * __v_106); let __v_114: G = (__v_73 * __v_107); let __v_115: G = (__v_75 * __v_108); let __v_116: G = (__v_77 * __v_109); let __v_117: G = (__v_79 * __v_110); let __v_118: G = (__v_81 * __v_111); let __v_119: G = (__v_117 + __v_118); let __v_120: G = (__v_116 + __v_119); let __v_121: G = (__v_115 + __v_120); let __v_122: G = (__v_114 + __v_121); let __v_123: G = (__v_113 + __v_122); let __v_124: G = (__v_112 + __v_123); let __v_125: G = (__v_104 + __v_124); if (__v_125 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_111 - __v_90); let __v_127: G = (__v_110 + __v_126); let __v_128: G = (__v_109 + __v_127); let __v_129: G = (__v_108 + __v_128); let __v_130: G = G::from_bool((__v_129 == G::ZERO)); let __v_131: G = (__v_106 + __v_107); let __v_132: G = (__v_105 + __v_131); let __v_133: G = (__v_104 + __v_132); let __v_134: G = G::from_bool((__v_133 == G::ZERO)); let __v_135: G = (__v_100 - __v_134); let __v_136: G = (__v_130 * __v_135); let __v_137: G = (__v_100 - __v_136); if (__v_137 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_137.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes(); let __v_138: G = G::from_u8(__gb[0]); let __v_139: G = G::from_u8(__gb[1]); let __v_140: G = G::from_u8(__gb[2]); let __v_141: G = G::from_u8(__gb[3]); let __v_142: G = G::from_u8(__gb[4]); let __v_143: G = G::from_u8(__gb[5]); let __v_144: G = G::from_u8(__gb[6]); let __v_145: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_138; let __vj = __v_139; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_140; let __vj = __v_141; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_142; let __vj = __v_143; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_146: G = (__v_69 * __v_139); let __v_147: G = (__v_71 * __v_140); let __v_148: G = (__v_73 * __v_141); let __v_149: G = (__v_75 * __v_142); let __v_150: G = (__v_77 * __v_143); let __v_151: G = (__v_79 * __v_144); let __v_152: G = (__v_81 * __v_145); let __v_153: G = (__v_151 + __v_152); let __v_154: G = (__v_150 + __v_153); let __v_155: G = (__v_149 + __v_154); let __v_156: G = (__v_148 + __v_155); let __v_157: G = (__v_147 + __v_156); let __v_158: G = (__v_146 + __v_157); let __v_159: G = (__v_138 + __v_158); if (__v_159 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __v_160: G = (__v_145 - __v_90); let __v_161: G = (__v_144 + __v_160); let __v_162: G = (__v_143 + __v_161); let __v_163: G = (__v_142 + __v_162); let __v_164: G = G::from_bool((__v_163 == G::ZERO)); let __v_165: G = (__v_140 + __v_141); let __v_166: G = (__v_139 + __v_165); let __v_167: G = (__v_138 + __v_166); let __v_168: G = G::from_bool((__v_167 == G::ZERO)); let __v_169: G = (__v_100 - __v_168); let __v_170: G = (__v_164 * __v_169); let __v_171: G = (__v_100 - __v_170); if (__v_171 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_101] = [__v_46, __v_43, __v_50, __v_31, __v_54, __v_41, __v_1, __v_11, __v_59, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_55]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_101(inp: [G; IN_101], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_49, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool(__v_56 == G::ZERO); let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_58 + __v_58; let __v_60: G = __v_48 + __v_59; let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_61: G = G::from_u8(__gb[0]); let __v_62: G = G::from_u8(__gb[1]); let __v_63: G = G::from_u8(__gb[2]); let __v_64: G = G::from_u8(__gb[3]); let __v_65: G = G::from_u8(__gb[4]); let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_69: G = G::from_u64(256); let __v_70: G = __v_69 * __v_62; let __v_71: G = G::from_u64(65536); let __v_72: G = __v_71 * __v_63; let __v_73: G = G::from_u64(16777216); let __v_74: G = __v_73 * __v_64; let __v_75: G = G::from_u64(4294967296); let __v_76: G = __v_75 * __v_65; let __v_77: G = G::from_u64(1099511627776); let __v_78: G = __v_77 * __v_66; let __v_79: G = G::from_u64(281474976710656); let __v_80: G = __v_79 * __v_67; let __v_81: G = G::from_u64(72057594037927936); let __v_82: G = __v_81 * __v_68; let __v_83: G = __v_80 + __v_82; let __v_84: G = __v_78 + __v_83; let __v_85: G = __v_76 + __v_84; let __v_86: G = __v_74 + __v_85; let __v_87: G = __v_72 + __v_86; let __v_88: G = __v_70 + __v_87; let __v_89: G = __v_61 + __v_88; if (__v_89 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_90: G = G::from_u64(1020); let __v_91: G = __v_68 - __v_90; let __v_92: G = __v_67 + __v_91; let __v_93: G = __v_66 + __v_92; let __v_94: G = __v_65 + __v_93; let __v_95: G = G::from_bool(__v_94 == G::ZERO); let __v_96: G = __v_63 + __v_64; let __v_97: G = __v_62 + __v_96; let __v_98: G = __v_61 + __v_97; let __v_99: G = G::from_bool(__v_98 == G::ZERO); let __v_100: G = G::from_u64(1); let __v_101: G = __v_100 - __v_99; let __v_102: G = __v_95 * __v_101; let __v_103: G = __v_100 - __v_102; if (__v_103 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_59.as_canonical_u64().to_le_bytes(); let __v_104: G = G::from_u8(__gb[0]); let __v_105: G = G::from_u8(__gb[1]); let __v_106: G = G::from_u8(__gb[2]); let __v_107: G = G::from_u8(__gb[3]); let __v_108: G = G::from_u8(__gb[4]); let __v_109: G = G::from_u8(__gb[5]); let __v_110: G = G::from_u8(__gb[6]); let __v_111: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_104; let __vj = __v_105; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_106; let __vj = __v_107; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_112: G = __v_69 * __v_105; let __v_113: G = __v_71 * __v_106; let __v_114: G = __v_73 * __v_107; let __v_115: G = __v_75 * __v_108; let __v_116: G = __v_77 * __v_109; let __v_117: G = __v_79 * __v_110; let __v_118: G = __v_81 * __v_111; let __v_119: G = __v_117 + __v_118; let __v_120: G = __v_116 + __v_119; let __v_121: G = __v_115 + __v_120; let __v_122: G = __v_114 + __v_121; let __v_123: G = __v_113 + __v_122; let __v_124: G = __v_112 + __v_123; let __v_125: G = __v_104 + __v_124; if (__v_125 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None }); } let __v_126: G = __v_111 - __v_90; let __v_127: G = __v_110 + __v_126; let __v_128: G = __v_109 + __v_127; let __v_129: G = __v_108 + __v_128; let __v_130: G = G::from_bool(__v_129 == G::ZERO); let __v_131: G = __v_106 + __v_107; let __v_132: G = __v_105 + __v_131; let __v_133: G = __v_104 + __v_132; let __v_134: G = G::from_bool(__v_133 == G::ZERO); let __v_135: G = __v_100 - __v_134; let __v_136: G = __v_130 * __v_135; let __v_137: G = __v_100 - __v_136; if (__v_137 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_137.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes(); let __v_138: G = G::from_u8(__gb[0]); let __v_139: G = G::from_u8(__gb[1]); let __v_140: G = G::from_u8(__gb[2]); let __v_141: G = G::from_u8(__gb[3]); let __v_142: G = G::from_u8(__gb[4]); let __v_143: G = G::from_u8(__gb[5]); let __v_144: G = G::from_u8(__gb[6]); let __v_145: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_138; let __vj = __v_139; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_140; let __vj = __v_141; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_142; let __vj = __v_143; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_146: G = __v_69 * __v_139; let __v_147: G = __v_71 * __v_140; let __v_148: G = __v_73 * __v_141; let __v_149: G = __v_75 * __v_142; let __v_150: G = __v_77 * __v_143; let __v_151: G = __v_79 * __v_144; let __v_152: G = __v_81 * __v_145; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_150 + __v_153; let __v_155: G = __v_149 + __v_154; let __v_156: G = __v_148 + __v_155; let __v_157: G = __v_147 + __v_156; let __v_158: G = __v_146 + __v_157; let __v_159: G = __v_138 + __v_158; if (__v_159 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __v_160: G = __v_145 - __v_90; let __v_161: G = __v_144 + __v_160; let __v_162: G = __v_143 + __v_161; let __v_163: G = __v_142 + __v_162; let __v_164: G = G::from_bool(__v_163 == G::ZERO); let __v_165: G = __v_140 + __v_141; let __v_166: G = __v_139 + __v_165; let __v_167: G = __v_138 + __v_166; let __v_168: G = G::from_bool(__v_167 == G::ZERO); let __v_169: G = __v_100 - __v_168; let __v_170: G = __v_164 * __v_169; let __v_171: G = __v_100 - __v_170; if (__v_171 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_101] = [__v_46, __v_43, __v_50, __v_31, __v_54, __v_41, __v_1, __v_11, __v_59, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_55]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_102: usize = 57; const IN_102: usize = 57; const OUT_102: usize = 1; -fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 10] = [__v_57, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 10] = [__v_57, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 10] = [__v_57, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_59]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 10] = [__v_57, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_60]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 10] = [__v_57, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_61]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 10] = [__v_57, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_62]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_63]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_64]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 10] = [__v_57, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 10] = [__v_57, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 10] = [__v_57, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_59]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 10] = [__v_57, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_60]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 10] = [__v_57, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_61]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 10] = [__v_57, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_62]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_63]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_64]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_103: usize = 2; const IN_103: usize = 2; const OUT_103: usize = 3; -fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_4: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_3, __v_4, __v_0]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, (&__args[..]))?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { (*(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91])) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = __r_arr[3]; let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = __r_arr[6]; let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_50, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, (&__args[..]))?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { (*(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99])) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool((__v_57 == G::ZERO)); let __v_59: G = (__v_57 + __v_58); let __v_60: G = (__v_59 + __v_59); let __v_61: G = (__v_49 + __v_60); let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes(); let __v_62: G = G::from_u8(__gb[0]); let __v_63: G = G::from_u8(__gb[1]); let __v_64: G = G::from_u8(__gb[2]); let __v_65: G = G::from_u8(__gb[3]); let __v_66: G = G::from_u8(__gb[4]); let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_70: G = G::from_u64(256); let __v_71: G = (__v_70 * __v_63); let __v_72: G = G::from_u64(65536); let __v_73: G = (__v_72 * __v_64); let __v_74: G = G::from_u64(16777216); let __v_75: G = (__v_74 * __v_65); let __v_76: G = G::from_u64(4294967296); let __v_77: G = (__v_76 * __v_66); let __v_78: G = G::from_u64(1099511627776); let __v_79: G = (__v_78 * __v_67); let __v_80: G = G::from_u64(281474976710656); let __v_81: G = (__v_80 * __v_68); let __v_82: G = G::from_u64(72057594037927936); let __v_83: G = (__v_82 * __v_69); let __v_84: G = (__v_81 + __v_83); let __v_85: G = (__v_79 + __v_84); let __v_86: G = (__v_77 + __v_85); let __v_87: G = (__v_75 + __v_86); let __v_88: G = (__v_73 + __v_87); let __v_89: G = (__v_71 + __v_88); let __v_90: G = (__v_62 + __v_89); if (__v_90 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None }); } let __v_91: G = G::from_u64(1020); let __v_92: G = (__v_69 - __v_91); let __v_93: G = (__v_68 + __v_92); let __v_94: G = (__v_67 + __v_93); let __v_95: G = (__v_66 + __v_94); let __v_96: G = G::from_bool((__v_95 == G::ZERO)); let __v_97: G = (__v_64 + __v_65); let __v_98: G = (__v_63 + __v_97); let __v_99: G = (__v_62 + __v_98); let __v_100: G = G::from_bool((__v_99 == G::ZERO)); let __v_101: G = G::from_u64(1); let __v_102: G = (__v_101 - __v_100); let __v_103: G = (__v_96 * __v_102); let __v_104: G = (__v_101 - __v_103); if (__v_104 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_105: G = G::from_u8(__gb[0]); let __v_106: G = G::from_u8(__gb[1]); let __v_107: G = G::from_u8(__gb[2]); let __v_108: G = G::from_u8(__gb[3]); let __v_109: G = G::from_u8(__gb[4]); let __v_110: G = G::from_u8(__gb[5]); let __v_111: G = G::from_u8(__gb[6]); let __v_112: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_105; let __vj = __v_106; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_113: G = (__v_70 * __v_106); let __v_114: G = (__v_72 * __v_107); let __v_115: G = (__v_74 * __v_108); let __v_116: G = (__v_76 * __v_109); let __v_117: G = (__v_78 * __v_110); let __v_118: G = (__v_80 * __v_111); let __v_119: G = (__v_82 * __v_112); let __v_120: G = (__v_118 + __v_119); let __v_121: G = (__v_117 + __v_120); let __v_122: G = (__v_116 + __v_121); let __v_123: G = (__v_115 + __v_122); let __v_124: G = (__v_114 + __v_123); let __v_125: G = (__v_113 + __v_124); let __v_126: G = (__v_105 + __v_125); if (__v_126 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_127: G = (__v_112 - __v_91); let __v_128: G = (__v_111 + __v_127); let __v_129: G = (__v_110 + __v_128); let __v_130: G = (__v_109 + __v_129); let __v_131: G = G::from_bool((__v_130 == G::ZERO)); let __v_132: G = (__v_107 + __v_108); let __v_133: G = (__v_106 + __v_132); let __v_134: G = (__v_105 + __v_133); let __v_135: G = G::from_bool((__v_134 == G::ZERO)); let __v_136: G = (__v_101 - __v_135); let __v_137: G = (__v_131 * __v_136); let __v_138: G = (__v_101 - __v_137); if (__v_138 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes(); let __v_139: G = G::from_u8(__gb[0]); let __v_140: G = G::from_u8(__gb[1]); let __v_141: G = G::from_u8(__gb[2]); let __v_142: G = G::from_u8(__gb[3]); let __v_143: G = G::from_u8(__gb[4]); let __v_144: G = G::from_u8(__gb[5]); let __v_145: G = G::from_u8(__gb[6]); let __v_146: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_139; let __vj = __v_140; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_141; let __vj = __v_142; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_143; let __vj = __v_144; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_147: G = (__v_70 * __v_140); let __v_148: G = (__v_72 * __v_141); let __v_149: G = (__v_74 * __v_142); let __v_150: G = (__v_76 * __v_143); let __v_151: G = (__v_78 * __v_144); let __v_152: G = (__v_80 * __v_145); let __v_153: G = (__v_82 * __v_146); let __v_154: G = (__v_152 + __v_153); let __v_155: G = (__v_151 + __v_154); let __v_156: G = (__v_150 + __v_155); let __v_157: G = (__v_149 + __v_156); let __v_158: G = (__v_148 + __v_157); let __v_159: G = (__v_147 + __v_158); let __v_160: G = (__v_139 + __v_159); if (__v_160 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_161: G = (__v_146 - __v_91); let __v_162: G = (__v_145 + __v_161); let __v_163: G = (__v_144 + __v_162); let __v_164: G = (__v_143 + __v_163); let __v_165: G = G::from_bool((__v_164 == G::ZERO)); let __v_166: G = (__v_141 + __v_142); let __v_167: G = (__v_140 + __v_166); let __v_168: G = (__v_139 + __v_167); let __v_169: G = G::from_bool((__v_168 == G::ZERO)); let __v_170: G = (__v_101 - __v_169); let __v_171: G = (__v_165 * __v_170); let __v_172: G = (__v_101 - __v_171); if (__v_172 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __v_173: G = (__v_1 - __v_101); let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, (&__args[..]))?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { (*(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103])) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __v_176: G = __r_arr[2]; let __v_177: G = { let __values: [G; 11] = [__v_46, __v_47, __v_44, __v_51, __v_32, __v_55, __v_42, __v_2, __v_12, __v_60, __v_174]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_178: G = { let __values: [G; 10] = [__v_46, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_175]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_179: G = { let __values: [G; 10] = [__v_46, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_178]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_180: G = { let __values: [G; 10] = [__v_46, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_179]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_181: G = { let __values: [G; 10] = [__v_46, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_180]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_182: G = { let __values: [G; 10] = [__v_46, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_181]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_183: G = { let __values: [G; 10] = [__v_46, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_182]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_184: G = { let __values: [G; 10] = [__v_46, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_183]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_177, __v_184, __v_176]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_4: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_3, __v_4, __v_0]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = __r_arr[3]; let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = __r_arr[6]; let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_50, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool(__v_57 == G::ZERO); let __v_59: G = __v_57 + __v_58; let __v_60: G = __v_59 + __v_59; let __v_61: G = __v_49 + __v_60; let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes(); let __v_62: G = G::from_u8(__gb[0]); let __v_63: G = G::from_u8(__gb[1]); let __v_64: G = G::from_u8(__gb[2]); let __v_65: G = G::from_u8(__gb[3]); let __v_66: G = G::from_u8(__gb[4]); let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_70: G = G::from_u64(256); let __v_71: G = __v_70 * __v_63; let __v_72: G = G::from_u64(65536); let __v_73: G = __v_72 * __v_64; let __v_74: G = G::from_u64(16777216); let __v_75: G = __v_74 * __v_65; let __v_76: G = G::from_u64(4294967296); let __v_77: G = __v_76 * __v_66; let __v_78: G = G::from_u64(1099511627776); let __v_79: G = __v_78 * __v_67; let __v_80: G = G::from_u64(281474976710656); let __v_81: G = __v_80 * __v_68; let __v_82: G = G::from_u64(72057594037927936); let __v_83: G = __v_82 * __v_69; let __v_84: G = __v_81 + __v_83; let __v_85: G = __v_79 + __v_84; let __v_86: G = __v_77 + __v_85; let __v_87: G = __v_75 + __v_86; let __v_88: G = __v_73 + __v_87; let __v_89: G = __v_71 + __v_88; let __v_90: G = __v_62 + __v_89; if (__v_90 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None }); } let __v_91: G = G::from_u64(1020); let __v_92: G = __v_69 - __v_91; let __v_93: G = __v_68 + __v_92; let __v_94: G = __v_67 + __v_93; let __v_95: G = __v_66 + __v_94; let __v_96: G = G::from_bool(__v_95 == G::ZERO); let __v_97: G = __v_64 + __v_65; let __v_98: G = __v_63 + __v_97; let __v_99: G = __v_62 + __v_98; let __v_100: G = G::from_bool(__v_99 == G::ZERO); let __v_101: G = G::from_u64(1); let __v_102: G = __v_101 - __v_100; let __v_103: G = __v_96 * __v_102; let __v_104: G = __v_101 - __v_103; if (__v_104 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_105: G = G::from_u8(__gb[0]); let __v_106: G = G::from_u8(__gb[1]); let __v_107: G = G::from_u8(__gb[2]); let __v_108: G = G::from_u8(__gb[3]); let __v_109: G = G::from_u8(__gb[4]); let __v_110: G = G::from_u8(__gb[5]); let __v_111: G = G::from_u8(__gb[6]); let __v_112: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_105; let __vj = __v_106; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_113: G = __v_70 * __v_106; let __v_114: G = __v_72 * __v_107; let __v_115: G = __v_74 * __v_108; let __v_116: G = __v_76 * __v_109; let __v_117: G = __v_78 * __v_110; let __v_118: G = __v_80 * __v_111; let __v_119: G = __v_82 * __v_112; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_117 + __v_120; let __v_122: G = __v_116 + __v_121; let __v_123: G = __v_115 + __v_122; let __v_124: G = __v_114 + __v_123; let __v_125: G = __v_113 + __v_124; let __v_126: G = __v_105 + __v_125; if (__v_126 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_127: G = __v_112 - __v_91; let __v_128: G = __v_111 + __v_127; let __v_129: G = __v_110 + __v_128; let __v_130: G = __v_109 + __v_129; let __v_131: G = G::from_bool(__v_130 == G::ZERO); let __v_132: G = __v_107 + __v_108; let __v_133: G = __v_106 + __v_132; let __v_134: G = __v_105 + __v_133; let __v_135: G = G::from_bool(__v_134 == G::ZERO); let __v_136: G = __v_101 - __v_135; let __v_137: G = __v_131 * __v_136; let __v_138: G = __v_101 - __v_137; if (__v_138 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes(); let __v_139: G = G::from_u8(__gb[0]); let __v_140: G = G::from_u8(__gb[1]); let __v_141: G = G::from_u8(__gb[2]); let __v_142: G = G::from_u8(__gb[3]); let __v_143: G = G::from_u8(__gb[4]); let __v_144: G = G::from_u8(__gb[5]); let __v_145: G = G::from_u8(__gb[6]); let __v_146: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_139; let __vj = __v_140; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_141; let __vj = __v_142; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_143; let __vj = __v_144; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_147: G = __v_70 * __v_140; let __v_148: G = __v_72 * __v_141; let __v_149: G = __v_74 * __v_142; let __v_150: G = __v_76 * __v_143; let __v_151: G = __v_78 * __v_144; let __v_152: G = __v_80 * __v_145; let __v_153: G = __v_82 * __v_146; let __v_154: G = __v_152 + __v_153; let __v_155: G = __v_151 + __v_154; let __v_156: G = __v_150 + __v_155; let __v_157: G = __v_149 + __v_156; let __v_158: G = __v_148 + __v_157; let __v_159: G = __v_147 + __v_158; let __v_160: G = __v_139 + __v_159; if (__v_160 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_161: G = __v_146 - __v_91; let __v_162: G = __v_145 + __v_161; let __v_163: G = __v_144 + __v_162; let __v_164: G = __v_143 + __v_163; let __v_165: G = G::from_bool(__v_164 == G::ZERO); let __v_166: G = __v_141 + __v_142; let __v_167: G = __v_140 + __v_166; let __v_168: G = __v_139 + __v_167; let __v_169: G = G::from_bool(__v_168 == G::ZERO); let __v_170: G = __v_101 - __v_169; let __v_171: G = __v_165 * __v_170; let __v_172: G = __v_101 - __v_171; if (__v_172 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __v_173: G = __v_1 - __v_101; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __v_176: G = __r_arr[2]; let __v_177: G = { let __values: [G; 11] = [__v_46, __v_47, __v_44, __v_51, __v_32, __v_55, __v_42, __v_2, __v_12, __v_60, __v_174]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_178: G = { let __values: [G; 10] = [__v_46, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_175]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_179: G = { let __values: [G; 10] = [__v_46, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_178]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_180: G = { let __values: [G; 10] = [__v_46, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_179]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_181: G = { let __values: [G; 10] = [__v_46, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_180]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_182: G = { let __values: [G; 10] = [__v_46, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_181]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_183: G = { let __values: [G; 10] = [__v_46, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_182]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_184: G = { let __values: [G; 10] = [__v_46, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_183]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_177, __v_184, __v_176]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_104: usize = 1; const IN_104: usize = 1; const OUT_104: usize = 3; -fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_104] = [__v_3, __v_3, __v_2]; record.function_queries[104].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, (&__args[..]))?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { (*(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95])) }; __ret }, _ => { aiur_fn_95::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_104] = [__v_7, __v_5, __v_6]; record.function_queries[104].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_104] = [__v_3, __v_3, __v_2]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_104] = [__v_7, __v_5, __v_6]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_105: usize = 2; const IN_105: usize = 2; const OUT_105: usize = 2; -fn aiur_fn_105(inp: [G; IN_105], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_3, __v_0]; record.function_queries[105].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { 65535u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_9, __v_7]; record.function_queries[105].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_10, __v_7]; record.function_queries[105].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_105(inp: [G; IN_105], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_3, __v_0]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { 65535u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_9, __v_7]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_10, __v_7]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_106: usize = 1; const IN_106: usize = 1; const OUT_106: usize = 9; -fn aiur_fn_106(inp: [G; IN_106], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_106] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_106(inp: [G; IN_106], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_106] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_107: usize = 1; const IN_107: usize = 1; const OUT_107: usize = 13; -fn aiur_fn_107(inp: [G; IN_107], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = __r_arr[4]; let __v_86: G = __r_arr[5]; let __v_87: G = __r_arr[6]; let __v_88: G = __r_arr[7]; let __v_89: G = __r_arr[8]; let __v_90: G = __r_arr[9]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, (&__args[..]))?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { (*(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103])) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, (&__args[..]))?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { (*(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104])) }; __ret }, _ => { aiur_fn_104::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_96, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = { let __values: [G; 10] = [__v_71, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_92]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_80, __v_99]; 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_100: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_100, __v_91, __v_94, __v_95, __v_97, __v_98]; record.function_queries[107].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_107(inp: [G; IN_107], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = __r_arr[4]; let __v_86: G = __r_arr[5]; let __v_87: G = __r_arr[6]; let __v_88: G = __r_arr[7]; let __v_89: G = __r_arr[8]; let __v_90: G = __r_arr[9]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, &__args[..])?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => { aiur_fn_104::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_96, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = { let __values: [G; 10] = [__v_71, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_92]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_80, __v_99]; 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_100: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_100, __v_91, __v_94, __v_95, __v_97, __v_98]; record.function_queries[107].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_108: usize = 5; const IN_108: usize = 5; const OUT_108: usize = 1; -fn aiur_fn_108(inp: [G; IN_108], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_108] = [__v_9]; record.function_queries[108].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_108(inp: [G; IN_108], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_108] = [__v_9]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_109: usize = 33; const IN_109: usize = 33; const OUT_109: usize = 1; -fn aiur_fn_109(inp: [G; IN_109], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_40]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_109(inp: [G; IN_109], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_40]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_110: usize = 32; const IN_110: usize = 32; const OUT_110: usize = 32; -fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __ret: [G; OUT_110] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __ret: [G; OUT_110] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_111: usize = 2; const IN_111: usize = 2; const OUT_111: usize = 1; -fn aiur_fn_111(inp: [G; IN_111], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(133); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(187); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(243); let __v_11: G = G::from_u64(110); let __v_12: G = G::from_u64(60); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(245); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(165); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(14); let __v_20: G = G::from_u64(81); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(171); let __v_26: G = G::from_u64(217); let __v_27: G = G::from_u64(131); let __v_28: G = G::from_u64(31); let __v_29: G = G::from_u64(25); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(224); let __v_32: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; let __v_36: G = __loaded[3]; let __v_37: G = __loaded[4]; let __v_38: G = __loaded[5]; let __v_39: G = __loaded[6]; let __v_40: G = __loaded[7]; let __v_41: G = __loaded[8]; let __v_42: G = __loaded[9]; let __v_43: G = __loaded[10]; let __v_44: G = __loaded[11]; let __v_45: G = __loaded[12]; let __v_46: G = __loaded[13]; let __v_47: G = __loaded[14]; let __v_48: G = __loaded[15]; let __v_49: G = __loaded[16]; let __v_50: G = __loaded[17]; let __v_51: G = __loaded[18]; let __v_52: G = __loaded[19]; let __v_53: G = __loaded[20]; let __v_54: G = __loaded[21]; let __v_55: G = __loaded[22]; let __v_56: G = __loaded[23]; let __v_57: G = __loaded[24]; let __v_58: G = __loaded[25]; let __v_59: G = __loaded[26]; let __v_60: G = __loaded[27]; let __v_61: G = __loaded[28]; let __v_62: G = __loaded[29]; let __v_63: G = __loaded[30]; let __v_64: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_65: G = __loaded[0]; let __v_66: G = __loaded[1]; let __v_67: G = __loaded[2]; let __v_68: G = __loaded[3]; let __v_69: G = __loaded[4]; let __v_70: G = __loaded[5]; let __v_71: G = __loaded[6]; let __v_72: G = __loaded[7]; let __v_73: G = __loaded[8]; let __v_74: G = __loaded[9]; let __v_75: G = __loaded[10]; let __v_76: G = __loaded[11]; let __v_77: G = __loaded[12]; let __v_78: G = __loaded[13]; let __v_79: G = __loaded[14]; let __v_80: G = __loaded[15]; let __v_81: G = __loaded[16]; let __v_82: G = __loaded[17]; let __v_83: G = __loaded[18]; let __v_84: G = __loaded[19]; let __v_85: G = __loaded[20]; let __v_86: G = __loaded[21]; let __v_87: G = __loaded[22]; let __v_88: G = __loaded[23]; let __v_89: G = __loaded[24]; let __v_90: G = __loaded[25]; let __v_91: G = __loaded[26]; let __v_92: G = __loaded[27]; let __v_93: G = __loaded[28]; let __v_94: G = __loaded[29]; let __v_95: G = __loaded[30]; let __v_96: G = __loaded[31]; let __v_97: G = G::from_u64(0); let __v_98: G = G::from_u64(64); let __v_99: G = G::from_u64(11); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_97, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_98, __v_97, __v_97, __v_97, __v_99, __v_97, __v_97, __v_97, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; let __v_103: G = __r_arr[3]; let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = __r_arr[6]; let __v_107: G = __r_arr[7]; let __v_108: G = __r_arr[8]; let __v_109: G = __r_arr[9]; let __v_110: G = __r_arr[10]; let __v_111: G = __r_arr[11]; let __v_112: G = __r_arr[12]; let __v_113: G = __r_arr[13]; let __v_114: G = __r_arr[14]; let __v_115: G = __r_arr[15]; let __v_116: G = __r_arr[16]; let __v_117: G = __r_arr[17]; let __v_118: G = __r_arr[18]; let __v_119: G = __r_arr[19]; let __v_120: G = __r_arr[20]; let __v_121: G = __r_arr[21]; let __v_122: G = __r_arr[22]; let __v_123: G = __r_arr[23]; let __v_124: G = __r_arr[24]; let __v_125: G = __r_arr[25]; let __v_126: G = __r_arr[26]; let __v_127: G = __r_arr[27]; let __v_128: G = __r_arr[28]; let __v_129: G = __r_arr[29]; let __v_130: G = __r_arr[30]; let __v_131: G = __r_arr[31]; let __v_132: G = { let __values: [G; 32] = [__v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_132]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_111(inp: [G; IN_111], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(133); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(187); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(243); let __v_11: G = G::from_u64(110); let __v_12: G = G::from_u64(60); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(245); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(165); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(14); let __v_20: G = G::from_u64(81); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(171); let __v_26: G = G::from_u64(217); let __v_27: G = G::from_u64(131); let __v_28: G = G::from_u64(31); let __v_29: G = G::from_u64(25); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(224); let __v_32: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; let __v_36: G = __loaded[3]; let __v_37: G = __loaded[4]; let __v_38: G = __loaded[5]; let __v_39: G = __loaded[6]; let __v_40: G = __loaded[7]; let __v_41: G = __loaded[8]; let __v_42: G = __loaded[9]; let __v_43: G = __loaded[10]; let __v_44: G = __loaded[11]; let __v_45: G = __loaded[12]; let __v_46: G = __loaded[13]; let __v_47: G = __loaded[14]; let __v_48: G = __loaded[15]; let __v_49: G = __loaded[16]; let __v_50: G = __loaded[17]; let __v_51: G = __loaded[18]; let __v_52: G = __loaded[19]; let __v_53: G = __loaded[20]; let __v_54: G = __loaded[21]; let __v_55: G = __loaded[22]; let __v_56: G = __loaded[23]; let __v_57: G = __loaded[24]; let __v_58: G = __loaded[25]; let __v_59: G = __loaded[26]; let __v_60: G = __loaded[27]; let __v_61: G = __loaded[28]; let __v_62: G = __loaded[29]; let __v_63: G = __loaded[30]; let __v_64: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_65: G = __loaded[0]; let __v_66: G = __loaded[1]; let __v_67: G = __loaded[2]; let __v_68: G = __loaded[3]; let __v_69: G = __loaded[4]; let __v_70: G = __loaded[5]; let __v_71: G = __loaded[6]; let __v_72: G = __loaded[7]; let __v_73: G = __loaded[8]; let __v_74: G = __loaded[9]; let __v_75: G = __loaded[10]; let __v_76: G = __loaded[11]; let __v_77: G = __loaded[12]; let __v_78: G = __loaded[13]; let __v_79: G = __loaded[14]; let __v_80: G = __loaded[15]; let __v_81: G = __loaded[16]; let __v_82: G = __loaded[17]; let __v_83: G = __loaded[18]; let __v_84: G = __loaded[19]; let __v_85: G = __loaded[20]; let __v_86: G = __loaded[21]; let __v_87: G = __loaded[22]; let __v_88: G = __loaded[23]; let __v_89: G = __loaded[24]; let __v_90: G = __loaded[25]; let __v_91: G = __loaded[26]; let __v_92: G = __loaded[27]; let __v_93: G = __loaded[28]; let __v_94: G = __loaded[29]; let __v_95: G = __loaded[30]; let __v_96: G = __loaded[31]; let __v_97: G = G::from_u64(0); let __v_98: G = G::from_u64(64); let __v_99: G = G::from_u64(11); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_97, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_98, __v_97, __v_97, __v_97, __v_99, __v_97, __v_97, __v_97, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; let __v_103: G = __r_arr[3]; let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = __r_arr[6]; let __v_107: G = __r_arr[7]; let __v_108: G = __r_arr[8]; let __v_109: G = __r_arr[9]; let __v_110: G = __r_arr[10]; let __v_111: G = __r_arr[11]; let __v_112: G = __r_arr[12]; let __v_113: G = __r_arr[13]; let __v_114: G = __r_arr[14]; let __v_115: G = __r_arr[15]; let __v_116: G = __r_arr[16]; let __v_117: G = __r_arr[17]; let __v_118: G = __r_arr[18]; let __v_119: G = __r_arr[19]; let __v_120: G = __r_arr[20]; let __v_121: G = __r_arr[21]; let __v_122: G = __r_arr[22]; let __v_123: G = __r_arr[23]; let __v_124: G = __r_arr[24]; let __v_125: G = __r_arr[25]; let __v_126: G = __r_arr[26]; let __v_127: G = __r_arr[27]; let __v_128: G = __r_arr[28]; let __v_129: G = __r_arr[29]; let __v_130: G = __r_arr[30]; let __v_131: G = __r_arr[31]; let __v_132: G = { let __values: [G; 32] = [__v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_132]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_112: usize = 3; const IN_112: usize = 3; const OUT_112: usize = 1; -fn aiur_fn_112(inp: [G; IN_112], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_3]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_3]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_112(inp: [G; IN_112], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_3]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_3]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_113: usize = 2; const IN_113: usize = 2; const OUT_113: usize = 1; -fn aiur_fn_113(inp: [G; IN_113], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_5]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_3 - __v_1); let __v_6: G = G::from_bool((__v_5 == G::ZERO)); match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_113(inp: [G; IN_113], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_5]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_3 - __v_1; let __v_6: G = G::from_bool(__v_5 == G::ZERO); match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_114: usize = 3; const IN_114: usize = 3; const OUT_114: usize = 1; -fn aiur_fn_114(inp: [G; IN_114], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_7]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = (__v_7 - __v_2); let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_11]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_21]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_23]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_114(inp: [G; IN_114], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_7]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = __v_7 - __v_2; let __v_10: G = G::from_bool(__v_9 == G::ZERO); match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_11]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_21]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_23]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_115: usize = 3; const IN_115: usize = 3; const OUT_115: usize = 1; -fn aiur_fn_115(inp: [G; IN_115], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_115] = [__v_7]; record.function_queries[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, (&__args[..]))?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { (*(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115])) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_10]; record.function_queries[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, (&__args[..]))?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { (*(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115])) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_20]; record.function_queries[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, (&__args[..]))?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { (*(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115])) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_115] = [__v_22]; record.function_queries[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_115(inp: [G; IN_115], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_115] = [__v_7]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_10]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_20]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_115] = [__v_22]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_116: usize = 2; const IN_116: usize = 2; const OUT_116: usize = 11; -fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(256); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(65536); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(16777216); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(4294967296); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(1099511627776); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(281474976710656); let __v_23: G = (__v_22 * __v_9); let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = (__v_24 * __v_10); let __v_26: G = (__v_23 + __v_25); let __v_27: G = (__v_21 + __v_26); let __v_28: G = (__v_19 + __v_27); let __v_29: G = (__v_17 + __v_28); let __v_30: G = (__v_15 + __v_29); let __v_31: G = (__v_13 + __v_30); let __v_32: G = (__v_3 + __v_31); let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_33: G = G::from_u8(__gb[0]); let __v_34: G = G::from_u8(__gb[1]); let __v_35: G = G::from_u8(__gb[2]); let __v_36: G = G::from_u8(__gb[3]); let __v_37: G = G::from_u8(__gb[4]); let __v_38: G = G::from_u8(__gb[5]); let __v_39: G = G::from_u8(__gb[6]); let __v_40: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_41: G = (__v_12 * __v_34); let __v_42: G = (__v_14 * __v_35); let __v_43: G = (__v_16 * __v_36); let __v_44: G = (__v_18 * __v_37); let __v_45: G = (__v_20 * __v_38); let __v_46: G = (__v_22 * __v_39); let __v_47: G = (__v_24 * __v_40); let __v_48: G = (__v_46 + __v_47); let __v_49: G = (__v_45 + __v_48); let __v_50: G = (__v_44 + __v_49); let __v_51: G = (__v_43 + __v_50); let __v_52: G = (__v_42 + __v_51); let __v_53: G = (__v_41 + __v_52); let __v_54: G = (__v_33 + __v_53); if (__v_54 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_55: G = G::from_u64(1020); let __v_56: G = (__v_40 - __v_55); let __v_57: G = (__v_39 + __v_56); let __v_58: G = (__v_38 + __v_57); let __v_59: G = (__v_37 + __v_58); let __v_60: G = G::from_bool((__v_59 == G::ZERO)); let __v_61: G = (__v_35 + __v_36); let __v_62: G = (__v_34 + __v_61); let __v_63: G = (__v_33 + __v_62); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); let __v_65: G = G::from_u64(1); let __v_66: G = (__v_65 - __v_64); let __v_67: G = (__v_60 * __v_66); let __v_68: G = (__v_65 - __v_67); if (__v_68 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_116] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_65]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_0, __v_1, __v_15]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; let __v_23: G = __r_arr[8]; let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; let __ret: [G; OUT_116] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(256); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(281474976710656); let __v_23: G = __v_22 * __v_9; let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = __v_24 * __v_10; let __v_26: G = __v_23 + __v_25; let __v_27: G = __v_21 + __v_26; let __v_28: G = __v_19 + __v_27; let __v_29: G = __v_17 + __v_28; let __v_30: G = __v_15 + __v_29; let __v_31: G = __v_13 + __v_30; let __v_32: G = __v_3 + __v_31; let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_33: G = G::from_u8(__gb[0]); let __v_34: G = G::from_u8(__gb[1]); let __v_35: G = G::from_u8(__gb[2]); let __v_36: G = G::from_u8(__gb[3]); let __v_37: G = G::from_u8(__gb[4]); let __v_38: G = G::from_u8(__gb[5]); let __v_39: G = G::from_u8(__gb[6]); let __v_40: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_41: G = __v_12 * __v_34; let __v_42: G = __v_14 * __v_35; let __v_43: G = __v_16 * __v_36; let __v_44: G = __v_18 * __v_37; let __v_45: G = __v_20 * __v_38; let __v_46: G = __v_22 * __v_39; let __v_47: G = __v_24 * __v_40; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_45 + __v_48; let __v_50: G = __v_44 + __v_49; let __v_51: G = __v_43 + __v_50; let __v_52: G = __v_42 + __v_51; let __v_53: G = __v_41 + __v_52; let __v_54: G = __v_33 + __v_53; if (__v_54 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_55: G = G::from_u64(1020); let __v_56: G = __v_40 - __v_55; let __v_57: G = __v_39 + __v_56; let __v_58: G = __v_38 + __v_57; let __v_59: G = __v_37 + __v_58; let __v_60: G = G::from_bool(__v_59 == G::ZERO); let __v_61: G = __v_35 + __v_36; let __v_62: G = __v_34 + __v_61; let __v_63: G = __v_33 + __v_62; let __v_64: G = G::from_bool(__v_63 == G::ZERO); let __v_65: G = G::from_u64(1); let __v_66: G = __v_65 - __v_64; let __v_67: G = __v_60 * __v_66; let __v_68: G = __v_65 - __v_67; if (__v_68 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_116] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_65]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_0, __v_1, __v_15]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; let __v_23: G = __r_arr[8]; let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; let __ret: [G; OUT_116] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_117: usize = 6; const IN_117: usize = 6; const OUT_117: usize = 1; -fn aiur_fn_117(inp: [G; IN_117], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = __r_arr[6]; let __v_13: G = __r_arr[7]; let __v_14: G = __r_arr[8]; let __v_15: G = __r_arr[9]; let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; let __v_29: G = __loaded[4]; let __v_30: G = __loaded[5]; let __v_31: G = __loaded[6]; let __v_32: G = __loaded[7]; let __v_33: G = __loaded[8]; let __v_34: G = __loaded[9]; let __v_35: G = __loaded[10]; let __v_36: G = __loaded[11]; let __v_37: G = __loaded[12]; let __v_38: G = __loaded[13]; let __v_39: G = __loaded[14]; let __v_40: G = __loaded[15]; let __v_41: G = __loaded[16]; let __v_42: G = __loaded[17]; let __v_43: G = __loaded[18]; let __v_44: G = __loaded[19]; let __v_45: G = __loaded[20]; let __v_46: G = __loaded[21]; let __v_47: G = __loaded[22]; let __v_48: G = __loaded[23]; let __v_49: G = __loaded[24]; let __v_50: G = __loaded[25]; let __v_51: G = __loaded[26]; let __v_52: G = __loaded[27]; let __v_53: G = __loaded[28]; let __v_54: G = __loaded[29]; let __v_55: G = __loaded[30]; let __v_56: G = __loaded[31]; let __v_57: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = G::from_u64(11); let __v_67: G = G::from_u64(103); let __v_68: G = G::from_u64(230); let __v_69: G = G::from_u64(9); let __v_70: G = G::from_u64(106); let __v_71: G = G::from_u64(133); let __v_72: G = G::from_u64(174); let __v_73: G = G::from_u64(187); let __v_74: G = G::from_u64(114); let __v_75: G = G::from_u64(243); let __v_76: G = G::from_u64(110); let __v_77: G = G::from_u64(60); let __v_78: G = G::from_u64(58); let __v_79: G = G::from_u64(245); let __v_80: G = G::from_u64(79); let __v_81: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_57, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_67, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_57, __v_57, __v_57, __v_57, __v_66, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; let __v_85: G = __r_arr[3]; let __v_86: G = __r_arr[4]; let __v_87: G = __r_arr[5]; let __v_88: G = __r_arr[6]; let __v_89: G = __r_arr[7]; let __v_90: G = __r_arr[8]; let __v_91: G = __r_arr[9]; let __v_92: G = __r_arr[10]; let __v_93: G = __r_arr[11]; let __v_94: G = __r_arr[12]; let __v_95: G = __r_arr[13]; let __v_96: G = __r_arr[14]; let __v_97: G = __r_arr[15]; let __v_98: G = __r_arr[16]; let __v_99: G = __r_arr[17]; let __v_100: G = __r_arr[18]; let __v_101: G = __r_arr[19]; let __v_102: G = __r_arr[20]; let __v_103: G = __r_arr[21]; let __v_104: G = __r_arr[22]; let __v_105: G = __r_arr[23]; let __v_106: G = __r_arr[24]; let __v_107: G = __r_arr[25]; let __v_108: G = __r_arr[26]; let __v_109: G = __r_arr[27]; let __v_110: G = __r_arr[28]; let __v_111: G = __r_arr[29]; let __v_112: G = __r_arr[30]; let __v_113: G = __r_arr[31]; let __v_114: G = { let __values: [G; 34] = [__v_57, __v_5, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_117] = [__v_114]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; let __v_86: G = __r_arr[3]; let __v_87: G = __r_arr[4]; let __v_88: G = __r_arr[5]; let __v_89: G = __r_arr[6]; let __v_90: G = __r_arr[7]; let __v_91: G = __r_arr[8]; let __v_92: G = __r_arr[9]; let __v_93: G = __r_arr[10]; let __v_94: G = G::from_u64(8); let __v_95: G = (__v_82 + __v_93); let __v_96: G = (__v_71 + __v_95); let __v_97: G = (__v_60 + __v_96); let __v_98: G = (__v_49 + __v_97); let __v_99: G = (__v_38 + __v_98); let __v_100: G = (__v_27 + __v_99); let __v_101: G = (__v_16 + __v_100); let __v_102: G = (__v_94 * __v_101); let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; let __v_106: G = __loaded[3]; let __v_107: G = __loaded[4]; let __v_108: G = __loaded[5]; let __v_109: G = __loaded[6]; let __v_110: G = __loaded[7]; let __v_111: G = __loaded[8]; let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; match __v_113.as_canonical_u64() { 1u64 => { let __v_116: G = G::from_u64(1); break '__mc_0 [__v_116]; }, _ => { let __v_116: G = G::from_u64(0); break '__mc_0 [__v_116]; }, } }, _ => { let __v_113: G = G::from_u64(0); break '__mc_0 [__v_113]; }, } }; let __v_113: G = __mc_out___mc_0[0]; let __v_114: G = G::from_u64(15); let __v_115: G = (__v_2 - __v_114); let __v_116: G = G::from_bool((__v_115 == G::ZERO)); let __v_117: G = G::from_bool((__v_2 == G::ZERO)); let __v_118: G = (__v_113 * __v_116); let __v_119: G = (__v_116 - __v_118); let __v_120: G = (__v_113 + __v_119); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; let __v_124: G = __loaded[3]; let __v_125: G = __loaded[4]; let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, (&__args[..]))?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { (*(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4])) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_129: G = __r_arr[0]; let __v_130: G = (__v_113 * __v_129); let __v_131: G = G::from_u64(2); let __v_132: G = (__v_131 * __v_120); let __v_133: G = G::from_u64(8); let __v_134: G = (__v_133 * __v_130); let __v_135: G = (__v_132 + __v_134); let __v_136: G = (__v_117 + __v_135); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; let __v_140: G = __loaded[3]; let __v_141: G = __loaded[4]; let __v_142: G = __loaded[5]; let __v_143: G = __loaded[6]; let __v_144: G = __loaded[7]; let __v_145: G = __loaded[8]; let __v_146: G = __loaded[9]; let __v_147: G = __loaded[10]; let __v_148: G = __loaded[11]; let __v_149: G = __loaded[12]; let __v_150: G = __loaded[13]; let __v_151: G = __loaded[14]; let __v_152: G = __loaded[15]; let __v_153: G = __loaded[16]; let __v_154: G = __loaded[17]; let __v_155: G = __loaded[18]; let __v_156: G = __loaded[19]; let __v_157: G = __loaded[20]; let __v_158: G = __loaded[21]; let __v_159: G = __loaded[22]; let __v_160: G = __loaded[23]; let __v_161: G = __loaded[24]; let __v_162: G = __loaded[25]; let __v_163: G = __loaded[26]; let __v_164: G = __loaded[27]; let __v_165: G = __loaded[28]; let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; let __v_169: G = G::from_u64(103); let __v_170: G = G::from_u64(230); let __v_171: G = G::from_u64(9); let __v_172: G = G::from_u64(106); let __v_173: G = G::from_u64(133); let __v_174: G = G::from_u64(174); let __v_175: G = G::from_u64(187); let __v_176: G = G::from_u64(114); let __v_177: G = G::from_u64(243); let __v_178: G = G::from_u64(110); let __v_179: G = G::from_u64(60); let __v_180: G = G::from_u64(58); let __v_181: G = G::from_u64(245); let __v_182: G = G::from_u64(79); let __v_183: G = G::from_u64(165); let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_184, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_169, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_102, __v_184, __v_184, __v_184, __v_136, __v_184, __v_184, __v_184, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __v_188: G = __r_arr[3]; let __v_189: G = __r_arr[4]; let __v_190: G = __r_arr[5]; let __v_191: G = __r_arr[6]; let __v_192: G = __r_arr[7]; let __v_193: G = __r_arr[8]; let __v_194: G = __r_arr[9]; let __v_195: G = __r_arr[10]; let __v_196: G = __r_arr[11]; let __v_197: G = __r_arr[12]; let __v_198: G = __r_arr[13]; let __v_199: G = __r_arr[14]; let __v_200: G = __r_arr[15]; let __v_201: G = __r_arr[16]; let __v_202: G = __r_arr[17]; let __v_203: G = __r_arr[18]; let __v_204: G = __r_arr[19]; let __v_205: G = __r_arr[20]; let __v_206: G = __r_arr[21]; let __v_207: G = __r_arr[22]; let __v_208: G = __r_arr[23]; let __v_209: G = __r_arr[24]; let __v_210: G = __r_arr[25]; let __v_211: G = __r_arr[26]; let __v_212: G = __r_arr[27]; let __v_213: G = __r_arr[28]; let __v_214: G = __r_arr[29]; let __v_215: G = __r_arr[30]; let __v_216: G = __r_arr[31]; match __v_113.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(0); let __v_218: G = { let __values: [G; 34] = [__v_217, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_117] = [__v_218]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_116.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(103); let __v_218: G = G::from_u64(230); let __v_219: G = G::from_u64(9); let __v_220: G = G::from_u64(106); let __v_221: G = G::from_u64(133); let __v_222: G = G::from_u64(174); let __v_223: G = G::from_u64(187); let __v_224: G = G::from_u64(114); let __v_225: G = G::from_u64(243); let __v_226: G = G::from_u64(110); let __v_227: G = G::from_u64(60); let __v_228: G = G::from_u64(58); let __v_229: G = G::from_u64(245); let __v_230: G = G::from_u64(79); let __v_231: G = G::from_u64(165); let __v_232: G = G::from_u64(127); let __v_233: G = G::from_u64(82); let __v_234: G = G::from_u64(14); let __v_235: G = G::from_u64(81); let __v_236: G = G::from_u64(140); let __v_237: G = G::from_u64(104); let __v_238: G = G::from_u64(5); let __v_239: G = G::from_u64(155); let __v_240: G = G::from_u64(171); let __v_241: G = G::from_u64(217); let __v_242: G = G::from_u64(131); let __v_243: G = G::from_u64(31); let __v_244: G = G::from_u64(25); let __v_245: G = G::from_u64(205); let __v_246: G = G::from_u64(224); let __v_247: G = G::from_u64(91); let __v_248: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_249: G = __loaded[0]; let __v_250: G = __loaded[1]; let __v_251: G = __loaded[2]; let __v_252: G = __loaded[3]; let __v_253: G = __loaded[4]; let __v_254: G = __loaded[5]; let __v_255: G = __loaded[6]; let __v_256: G = __loaded[7]; let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(13, (&__args[..]))?) { [G::ZERO; OUT_13] } else { let (__hash, __hit) = record.function_queries[13].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[13].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { (*(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13])) }; __ret }, _ => { aiur_fn_13::(__args, __hash, record, io_buffer)? }, } } }; let __v_257: G = __r_arr[0]; let __v_258: G = __r_arr[1]; let __v_259: G = __r_arr[2]; let __v_260: G = __r_arr[3]; let __v_261: G = __r_arr[4]; let __v_262: G = __r_arr[5]; let __v_263: G = __r_arr[6]; let __v_264: G = __r_arr[7]; let __v_265: G = { let __values: [G; 8] = [__v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_266: G = { let __values: [G; 32] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_217, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_267: G = { let __values: [G; 34] = [__v_248, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_268: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_268]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_217: G = G::from_u64(1); let __v_218: G = (__v_2 + __v_217); let __v_219: G = { let __values: [G; 32] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_220]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +fn aiur_fn_117(inp: [G; IN_117], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = __r_arr[6]; let __v_13: G = __r_arr[7]; let __v_14: G = __r_arr[8]; let __v_15: G = __r_arr[9]; let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; let __v_29: G = __loaded[4]; let __v_30: G = __loaded[5]; let __v_31: G = __loaded[6]; let __v_32: G = __loaded[7]; let __v_33: G = __loaded[8]; let __v_34: G = __loaded[9]; let __v_35: G = __loaded[10]; let __v_36: G = __loaded[11]; let __v_37: G = __loaded[12]; let __v_38: G = __loaded[13]; let __v_39: G = __loaded[14]; let __v_40: G = __loaded[15]; let __v_41: G = __loaded[16]; let __v_42: G = __loaded[17]; let __v_43: G = __loaded[18]; let __v_44: G = __loaded[19]; let __v_45: G = __loaded[20]; let __v_46: G = __loaded[21]; let __v_47: G = __loaded[22]; let __v_48: G = __loaded[23]; let __v_49: G = __loaded[24]; let __v_50: G = __loaded[25]; let __v_51: G = __loaded[26]; let __v_52: G = __loaded[27]; let __v_53: G = __loaded[28]; let __v_54: G = __loaded[29]; let __v_55: G = __loaded[30]; let __v_56: G = __loaded[31]; let __v_57: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = G::from_u64(11); let __v_67: G = G::from_u64(103); let __v_68: G = G::from_u64(230); let __v_69: G = G::from_u64(9); let __v_70: G = G::from_u64(106); let __v_71: G = G::from_u64(133); let __v_72: G = G::from_u64(174); let __v_73: G = G::from_u64(187); let __v_74: G = G::from_u64(114); let __v_75: G = G::from_u64(243); let __v_76: G = G::from_u64(110); let __v_77: G = G::from_u64(60); let __v_78: G = G::from_u64(58); let __v_79: G = G::from_u64(245); let __v_80: G = G::from_u64(79); let __v_81: G = G::from_u64(165); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_57, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_67, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_57, __v_57, __v_57, __v_57, __v_66, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; let __v_85: G = __r_arr[3]; let __v_86: G = __r_arr[4]; let __v_87: G = __r_arr[5]; let __v_88: G = __r_arr[6]; let __v_89: G = __r_arr[7]; let __v_90: G = __r_arr[8]; let __v_91: G = __r_arr[9]; let __v_92: G = __r_arr[10]; let __v_93: G = __r_arr[11]; let __v_94: G = __r_arr[12]; let __v_95: G = __r_arr[13]; let __v_96: G = __r_arr[14]; let __v_97: G = __r_arr[15]; let __v_98: G = __r_arr[16]; let __v_99: G = __r_arr[17]; let __v_100: G = __r_arr[18]; let __v_101: G = __r_arr[19]; let __v_102: G = __r_arr[20]; let __v_103: G = __r_arr[21]; let __v_104: G = __r_arr[22]; let __v_105: G = __r_arr[23]; let __v_106: G = __r_arr[24]; let __v_107: G = __r_arr[25]; let __v_108: G = __r_arr[26]; let __v_109: G = __r_arr[27]; let __v_110: G = __r_arr[28]; let __v_111: G = __r_arr[29]; let __v_112: G = __r_arr[30]; let __v_113: G = __r_arr[31]; let __v_114: G = { let __values: [G; 34] = [__v_57, __v_5, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_117] = [__v_114]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; let __v_86: G = __r_arr[3]; let __v_87: G = __r_arr[4]; let __v_88: G = __r_arr[5]; let __v_89: G = __r_arr[6]; let __v_90: G = __r_arr[7]; let __v_91: G = __r_arr[8]; let __v_92: G = __r_arr[9]; let __v_93: G = __r_arr[10]; let __v_94: G = G::from_u64(8); let __v_95: G = __v_82 + __v_93; let __v_96: G = __v_71 + __v_95; let __v_97: G = __v_60 + __v_96; let __v_98: G = __v_49 + __v_97; let __v_99: G = __v_38 + __v_98; let __v_100: G = __v_27 + __v_99; let __v_101: G = __v_16 + __v_100; let __v_102: G = __v_94 * __v_101; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; let __v_106: G = __loaded[3]; let __v_107: G = __loaded[4]; let __v_108: G = __loaded[5]; let __v_109: G = __loaded[6]; let __v_110: G = __loaded[7]; let __v_111: G = __loaded[8]; let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; match __v_113.as_canonical_u64() { 1u64 => { let __v_116: G = G::from_u64(1); break '__mc_0 [__v_116]; }, _ => { let __v_116: G = G::from_u64(0); break '__mc_0 [__v_116]; }, } }, _ => { let __v_113: G = G::from_u64(0); break '__mc_0 [__v_113]; }, } }; let __v_113: G = __mc_out___mc_0[0]; let __v_114: G = G::from_u64(15); let __v_115: G = __v_2 - __v_114; let __v_116: G = G::from_bool(__v_115 == G::ZERO); let __v_117: G = G::from_bool(__v_2 == G::ZERO); let __v_118: G = __v_113 * __v_116; let __v_119: G = __v_116 - __v_118; let __v_120: G = __v_113 + __v_119; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; let __v_124: G = __loaded[3]; let __v_125: G = __loaded[4]; let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_129: G = __r_arr[0]; let __v_130: G = __v_113 * __v_129; let __v_131: G = G::from_u64(2); let __v_132: G = __v_131 * __v_120; let __v_133: G = G::from_u64(8); let __v_134: G = __v_133 * __v_130; let __v_135: G = __v_132 + __v_134; let __v_136: G = __v_117 + __v_135; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; let __v_140: G = __loaded[3]; let __v_141: G = __loaded[4]; let __v_142: G = __loaded[5]; let __v_143: G = __loaded[6]; let __v_144: G = __loaded[7]; let __v_145: G = __loaded[8]; let __v_146: G = __loaded[9]; let __v_147: G = __loaded[10]; let __v_148: G = __loaded[11]; let __v_149: G = __loaded[12]; let __v_150: G = __loaded[13]; let __v_151: G = __loaded[14]; let __v_152: G = __loaded[15]; let __v_153: G = __loaded[16]; let __v_154: G = __loaded[17]; let __v_155: G = __loaded[18]; let __v_156: G = __loaded[19]; let __v_157: G = __loaded[20]; let __v_158: G = __loaded[21]; let __v_159: G = __loaded[22]; let __v_160: G = __loaded[23]; let __v_161: G = __loaded[24]; let __v_162: G = __loaded[25]; let __v_163: G = __loaded[26]; let __v_164: G = __loaded[27]; let __v_165: G = __loaded[28]; let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; let __v_169: G = G::from_u64(103); let __v_170: G = G::from_u64(230); let __v_171: G = G::from_u64(9); let __v_172: G = G::from_u64(106); let __v_173: G = G::from_u64(133); let __v_174: G = G::from_u64(174); let __v_175: G = G::from_u64(187); let __v_176: G = G::from_u64(114); let __v_177: G = G::from_u64(243); let __v_178: G = G::from_u64(110); let __v_179: G = G::from_u64(60); let __v_180: G = G::from_u64(58); let __v_181: G = G::from_u64(245); let __v_182: G = G::from_u64(79); let __v_183: G = G::from_u64(165); let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_184, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_169, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_102, __v_184, __v_184, __v_184, __v_136, __v_184, __v_184, __v_184, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __v_188: G = __r_arr[3]; let __v_189: G = __r_arr[4]; let __v_190: G = __r_arr[5]; let __v_191: G = __r_arr[6]; let __v_192: G = __r_arr[7]; let __v_193: G = __r_arr[8]; let __v_194: G = __r_arr[9]; let __v_195: G = __r_arr[10]; let __v_196: G = __r_arr[11]; let __v_197: G = __r_arr[12]; let __v_198: G = __r_arr[13]; let __v_199: G = __r_arr[14]; let __v_200: G = __r_arr[15]; let __v_201: G = __r_arr[16]; let __v_202: G = __r_arr[17]; let __v_203: G = __r_arr[18]; let __v_204: G = __r_arr[19]; let __v_205: G = __r_arr[20]; let __v_206: G = __r_arr[21]; let __v_207: G = __r_arr[22]; let __v_208: G = __r_arr[23]; let __v_209: G = __r_arr[24]; let __v_210: G = __r_arr[25]; let __v_211: G = __r_arr[26]; let __v_212: G = __r_arr[27]; let __v_213: G = __r_arr[28]; let __v_214: G = __r_arr[29]; let __v_215: G = __r_arr[30]; let __v_216: G = __r_arr[31]; match __v_113.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(0); let __v_218: G = { let __values: [G; 34] = [__v_217, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_117] = [__v_218]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_116.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(103); let __v_218: G = G::from_u64(230); let __v_219: G = G::from_u64(9); let __v_220: G = G::from_u64(106); let __v_221: G = G::from_u64(133); let __v_222: G = G::from_u64(174); let __v_223: G = G::from_u64(187); let __v_224: G = G::from_u64(114); let __v_225: G = G::from_u64(243); let __v_226: G = G::from_u64(110); let __v_227: G = G::from_u64(60); let __v_228: G = G::from_u64(58); let __v_229: G = G::from_u64(245); let __v_230: G = G::from_u64(79); let __v_231: G = G::from_u64(165); let __v_232: G = G::from_u64(127); let __v_233: G = G::from_u64(82); let __v_234: G = G::from_u64(14); let __v_235: G = G::from_u64(81); let __v_236: G = G::from_u64(140); let __v_237: G = G::from_u64(104); let __v_238: G = G::from_u64(5); let __v_239: G = G::from_u64(155); let __v_240: G = G::from_u64(171); let __v_241: G = G::from_u64(217); let __v_242: G = G::from_u64(131); let __v_243: G = G::from_u64(31); let __v_244: G = G::from_u64(25); let __v_245: G = G::from_u64(205); let __v_246: G = G::from_u64(224); let __v_247: G = G::from_u64(91); let __v_248: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_249: G = __loaded[0]; let __v_250: G = __loaded[1]; let __v_251: G = __loaded[2]; let __v_252: G = __loaded[3]; let __v_253: G = __loaded[4]; let __v_254: G = __loaded[5]; let __v_255: G = __loaded[6]; let __v_256: G = __loaded[7]; let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(13, &__args[..])?) { [G::ZERO; OUT_13] } else { let (__hash, __hit) = record.function_queries[13].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[13].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => { aiur_fn_13::(__args, __hash, record, io_buffer)? }, } } }; let __v_257: G = __r_arr[0]; let __v_258: G = __r_arr[1]; let __v_259: G = __r_arr[2]; let __v_260: G = __r_arr[3]; let __v_261: G = __r_arr[4]; let __v_262: G = __r_arr[5]; let __v_263: G = __r_arr[6]; let __v_264: G = __r_arr[7]; let __v_265: G = { let __values: [G; 8] = [__v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_266: G = { let __values: [G; 32] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_217, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_267: G = { let __values: [G; 34] = [__v_248, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_268: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_268]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_217: G = G::from_u64(1); let __v_218: G = __v_2 + __v_217; let __v_219: G = { let __values: [G; 32] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_220]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_118: usize = 1; const IN_118: usize = 1; const OUT_118: usize = 32; -fn aiur_fn_118(inp: [G; IN_118], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 10] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_118] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_118(inp: [G; IN_118], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 10] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_118] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_119: usize = 3; const IN_119: usize = 3; const OUT_119: usize = 1; -fn aiur_fn_119(inp: [G; IN_119], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(174); let __v_10: G = G::from_u64(187); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(243); let __v_13: G = G::from_u64(110); let __v_14: G = G::from_u64(60); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(245); let __v_17: G = G::from_u64(79); let __v_18: G = G::from_u64(165); let __v_19: G = G::from_u64(127); let __v_20: G = G::from_u64(82); let __v_21: G = G::from_u64(14); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(140); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(217); let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(31); let __v_31: G = G::from_u64(25); let __v_32: G = G::from_u64(205); let __v_33: G = G::from_u64(224); let __v_34: G = G::from_u64(91); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 10] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 8] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_4, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 34] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; let __v_45: G = __r_arr[3]; let __v_46: G = __r_arr[4]; let __v_47: G = __r_arr[5]; let __v_48: G = __r_arr[6]; let __v_49: G = __r_arr[7]; let __v_50: G = __r_arr[8]; let __v_51: G = __r_arr[9]; let __v_52: G = __r_arr[10]; let __v_53: G = __r_arr[11]; let __v_54: G = __r_arr[12]; let __v_55: G = __r_arr[13]; let __v_56: G = __r_arr[14]; let __v_57: G = __r_arr[15]; let __v_58: G = __r_arr[16]; let __v_59: G = __r_arr[17]; let __v_60: G = __r_arr[18]; let __v_61: G = __r_arr[19]; let __v_62: G = __r_arr[20]; let __v_63: G = __r_arr[21]; let __v_64: G = __r_arr[22]; let __v_65: G = __r_arr[23]; let __v_66: G = __r_arr[24]; let __v_67: G = __r_arr[25]; let __v_68: G = __r_arr[26]; let __v_69: G = __r_arr[27]; let __v_70: G = __r_arr[28]; let __v_71: G = __r_arr[29]; let __v_72: G = __r_arr[30]; let __v_73: G = __r_arr[31]; let __v_74: G = { let __values: [G; 32] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_74]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_119(inp: [G; IN_119], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(174); let __v_10: G = G::from_u64(187); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(243); let __v_13: G = G::from_u64(110); let __v_14: G = G::from_u64(60); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(245); let __v_17: G = G::from_u64(79); let __v_18: G = G::from_u64(165); let __v_19: G = G::from_u64(127); let __v_20: G = G::from_u64(82); let __v_21: G = G::from_u64(14); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(140); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(217); let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(31); let __v_31: G = G::from_u64(25); let __v_32: G = G::from_u64(205); let __v_33: G = G::from_u64(224); let __v_34: G = G::from_u64(91); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 10] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 8] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_4, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 34] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; let __v_45: G = __r_arr[3]; let __v_46: G = __r_arr[4]; let __v_47: G = __r_arr[5]; let __v_48: G = __r_arr[6]; let __v_49: G = __r_arr[7]; let __v_50: G = __r_arr[8]; let __v_51: G = __r_arr[9]; let __v_52: G = __r_arr[10]; let __v_53: G = __r_arr[11]; let __v_54: G = __r_arr[12]; let __v_55: G = __r_arr[13]; let __v_56: G = __r_arr[14]; let __v_57: G = __r_arr[15]; let __v_58: G = __r_arr[16]; let __v_59: G = __r_arr[17]; let __v_60: G = __r_arr[18]; let __v_61: G = __r_arr[19]; let __v_62: G = __r_arr[20]; let __v_63: G = __r_arr[21]; let __v_64: G = __r_arr[22]; let __v_65: G = __r_arr[23]; let __v_66: G = __r_arr[24]; let __v_67: G = __r_arr[25]; let __v_68: G = __r_arr[26]; let __v_69: G = __r_arr[27]; let __v_70: G = __r_arr[28]; let __v_71: G = __r_arr[29]; let __v_72: G = __r_arr[30]; let __v_73: G = __r_arr[31]; let __v_74: G = { let __values: [G; 32] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_74]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_120: usize = 4; const IN_120: usize = 4; const OUT_120: usize = 1; -fn aiur_fn_120(inp: [G; IN_120], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_120] = [__v_3]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_6]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_120(inp: [G; IN_120], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_120] = [__v_3]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_6]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_121: usize = 1; const IN_121: usize = 1; const OUT_121: usize = 1; -fn aiur_fn_121(inp: [G; IN_121], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_121] = [__v_4]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_121] = [__v_7]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_121(inp: [G; IN_121], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_121] = [__v_4]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_4 * __v_5; let __v_7: G = __v_2 + __v_6; let __ret: [G; OUT_121] = [__v_7]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_122: usize = 2; const IN_122: usize = 2; const OUT_122: usize = 1; -fn aiur_fn_122(inp: [G; IN_122], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_122] = [__v_1]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_122] = [__v_0]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { match __v_9.as_canonical_u64() { _ => { let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_17]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = (__v_3 - __v_9); let __v_16: G = G::from_bool((__v_15 == G::ZERO)); match __v_16.as_canonical_u64() { 1u64 => { if (__v_6 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_19]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_19]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_122(inp: [G; IN_122], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_122] = [__v_1]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_122] = [__v_0]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { match __v_9.as_canonical_u64() { _ => { let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_17]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = __v_3 - __v_9; let __v_16: G = G::from_bool(__v_15 == G::ZERO); match __v_16.as_canonical_u64() { 1u64 => { if (__v_6 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_19]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_19]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_123: usize = 1; const IN_123: usize = 1; const OUT_123: usize = 2; -fn aiur_fn_123(inp: [G; IN_123], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 6] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_8, __v_8]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 6] = [__v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_15]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_16, __v_15]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_16, __v_17]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_123(inp: [G; IN_123], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 6] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_8, __v_8]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 6] = [__v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_15]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_16, __v_15]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_16, __v_17]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_124: usize = 1; const IN_124: usize = 1; const OUT_124: usize = 1; -fn aiur_fn_124(inp: [G; IN_124], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_124] = [__v_0]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_124] = [__v_0]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_17]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_124(inp: [G; IN_124], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_124] = [__v_0]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_124] = [__v_0]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_17]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_125: usize = 4; const IN_125: usize = 4; const OUT_125: usize = 1; -fn aiur_fn_125(inp: [G; IN_125], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 6] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_125] = [__v_10]; record.function_queries[125].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_125] = [__v_14]; record.function_queries[125].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_125(inp: [G; IN_125], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 6] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_125] = [__v_10]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_125] = [__v_14]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_126: usize = 4; const IN_126: usize = 4; const OUT_126: usize = 2; -fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 6] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_11, __v_1]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_13 - __v_23); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); match __v_25.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, (&__args[..]))?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { (*(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115])) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, (&__args[..]))?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { (*(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115])) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_29, __v_30]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_33, __v_31]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_34, __v_32]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, } }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 6] = [__v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_27]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_28, __v_22]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 6] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_11, __v_1]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __v_13 - __v_23; let __v_25: G = G::from_bool(__v_24 == G::ZERO); match __v_25.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_29, __v_30]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_33, __v_31]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_34, __v_32]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, } }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 6] = [__v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_27]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_126] = [__v_28, __v_22]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_127: usize = 4; const IN_127: usize = 4; const OUT_127: usize = 2; -fn aiur_fn_127(inp: [G; IN_127], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_0, __v_1]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_3 - __v_4); let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_127] = [__v_8, __v_9]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_127(inp: [G; IN_127], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_0, __v_1]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_3 - __v_4; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_127] = [__v_8, __v_9]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_128: usize = 6; const IN_128: usize = 6; const OUT_128: usize = 1; -fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_4, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_22]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_18]; 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_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_21); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __ret: [G; OUT_128] = [__v_27]; record.function_queries[128].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } +fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; let __v_9: G = G::from_bool(__v_8 == G::ZERO); let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_4, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_22]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_18]; 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_25: G = __r_arr[0]; let __v_26: G = __v_25 - __v_21; let __v_27: G = G::from_bool(__v_26 == G::ZERO); let __ret: [G; OUT_128] = [__v_27]; record.function_queries[128].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } const INPUT_SIZE_129: usize = 2; const IN_129: usize = 2; const OUT_129: usize = 1; -fn aiur_fn_129(inp: [G; IN_129], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_129] = [__v_1]; record.function_queries[129].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, (&__args[..]))?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { (*(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129])) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_7]; record.function_queries[129].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_129(inp: [G; IN_129], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_129] = [__v_1]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_7]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_130: usize = 2; const IN_130: usize = 2; const OUT_130: usize = 1; -fn aiur_fn_130(inp: [G; IN_130], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_130] = [__v_5]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_130] = [__v_6]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); let __ret: [G; OUT_130] = [__v_7]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_130(inp: [G; IN_130], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_130] = [__v_5]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_0 * __v_0; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_130] = [__v_6]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = __v_0 * __v_6; let __ret: [G; OUT_130] = [__v_7]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_131: usize = 8; const IN_131: usize = 8; const OUT_131: usize = 2; -fn aiur_fn_131(inp: [G; IN_131], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, (&__args[..]))?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { (*(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129])) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_13); let __v_15: G = (__v_4 + __v_6); let __v_16: G = (__v_5 + __v_7); let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __v_19: G = (__v_17 * __v_17); let __v_20: G = G::from_u64(7); let __v_21: G = (__v_18 * __v_18); let __v_22: G = (__v_20 * __v_21); let __v_23: G = (__v_19 - __v_22); let __v_24: G = aiur::execute::g_inverse_value(__v_23); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_25 - __v_8); let __v_27: G = (__v_23 * __v_26); if (__v_27 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_28: G = (__v_24 * __v_26); if (__v_28 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_29: G = (__v_17 * __v_24); let __v_30: G = (__v_18 - __v_18); let __v_31: G = (__v_30 * __v_24); let __v_32: G = (__v_15 * __v_29); let __v_33: G = (__v_16 * __v_31); let __v_34: G = (__v_20 * __v_33); let __v_35: G = (__v_32 + __v_34); let __v_36: G = (__v_15 * __v_31); let __v_37: G = (__v_16 * __v_29); let __v_38: G = (__v_36 + __v_37); let __v_39: G = (__v_4 - __v_6); let __v_40: G = (__v_5 - __v_7); let __v_41: G = (__v_14 * __v_14); let __v_42: G = (__v_41 - __v_22); let __v_43: G = aiur::execute::g_inverse_value(__v_42); let __v_44: G = (__v_42 * __v_43); let __v_45: G = (__v_44 - __v_8); let __v_46: G = (__v_42 * __v_45); if (__v_46 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_47: G = (__v_43 * __v_45); if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_48: G = (__v_14 * __v_43); let __v_49: G = (__v_30 * __v_43); let __v_50: G = (__v_39 * __v_48); let __v_51: G = (__v_40 * __v_49); let __v_52: G = (__v_20 * __v_51); let __v_53: G = (__v_50 + __v_52); let __v_54: G = (__v_39 * __v_49); let __v_55: G = (__v_40 * __v_48); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_2 * __v_53); let __v_58: G = (__v_3 * __v_56); let __v_59: G = (__v_20 * __v_58); let __v_60: G = (__v_57 + __v_59); let __v_61: G = (__v_2 * __v_56); let __v_62: G = (__v_3 * __v_53); let __v_63: G = (__v_61 + __v_62); let __v_64: G = (__v_35 + __v_60); let __v_65: G = (__v_38 + __v_63); let __ret: [G; OUT_131] = [__v_64, __v_65]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_131(inp: [G; IN_131], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 + __v_8; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_13; let __v_15: G = __v_4 + __v_6; let __v_16: G = __v_5 + __v_7; let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __v_19: G = __v_17 * __v_17; let __v_20: G = G::from_u64(7); let __v_21: G = __v_18 * __v_18; let __v_22: G = __v_20 * __v_21; let __v_23: G = __v_19 - __v_22; let __v_24: G = aiur::execute::g_inverse_value(__v_23); let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_25 - __v_8; let __v_27: G = __v_23 * __v_26; if (__v_27 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_28: G = __v_24 * __v_26; if (__v_28 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_29: G = __v_17 * __v_24; let __v_30: G = __v_18 - __v_18; let __v_31: G = __v_30 * __v_24; let __v_32: G = __v_15 * __v_29; let __v_33: G = __v_16 * __v_31; let __v_34: G = __v_20 * __v_33; let __v_35: G = __v_32 + __v_34; let __v_36: G = __v_15 * __v_31; let __v_37: G = __v_16 * __v_29; let __v_38: G = __v_36 + __v_37; let __v_39: G = __v_4 - __v_6; let __v_40: G = __v_5 - __v_7; let __v_41: G = __v_14 * __v_14; let __v_42: G = __v_41 - __v_22; let __v_43: G = aiur::execute::g_inverse_value(__v_42); let __v_44: G = __v_42 * __v_43; let __v_45: G = __v_44 - __v_8; let __v_46: G = __v_42 * __v_45; if (__v_46 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_47: G = __v_43 * __v_45; if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_48: G = __v_14 * __v_43; let __v_49: G = __v_30 * __v_43; let __v_50: G = __v_39 * __v_48; let __v_51: G = __v_40 * __v_49; let __v_52: G = __v_20 * __v_51; let __v_53: G = __v_50 + __v_52; let __v_54: G = __v_39 * __v_49; let __v_55: G = __v_40 * __v_48; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_2 * __v_53; let __v_58: G = __v_3 * __v_56; let __v_59: G = __v_20 * __v_58; let __v_60: G = __v_57 + __v_59; let __v_61: G = __v_2 * __v_56; let __v_62: G = __v_3 * __v_53; let __v_63: G = __v_61 + __v_62; let __v_64: G = __v_35 + __v_60; let __v_65: G = __v_38 + __v_63; let __ret: [G; OUT_131] = [__v_64, __v_65]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_132: usize = 2; const IN_132: usize = 2; const OUT_132: usize = 1; -fn aiur_fn_132(inp: [G; IN_132], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, (&__args[..]))?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { (*(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129])) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_2 * __v_7); let __ret: [G; OUT_132] = [__v_8]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_132(inp: [G; IN_132], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __v_2 * __v_7; let __ret: [G; OUT_132] = [__v_8]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_133: usize = 8; const IN_133: usize = 8; const OUT_133: usize = 4; -fn aiur_fn_133(inp: [G; IN_133], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_133] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; match __v_18.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(256); let __v_23: G = (__v_22 * __v_10); let __v_24: G = G::from_u64(65536); let __v_25: G = (__v_24 * __v_11); let __v_26: G = G::from_u64(16777216); let __v_27: G = (__v_26 * __v_12); let __v_28: G = G::from_u64(4294967296); let __v_29: G = (__v_28 * __v_13); let __v_30: G = G::from_u64(1099511627776); let __v_31: G = (__v_30 * __v_14); let __v_32: G = G::from_u64(281474976710656); let __v_33: G = (__v_32 * __v_15); let __v_34: G = G::from_u64(72057594037927936); let __v_35: G = (__v_34 * __v_16); let __v_36: G = (__v_33 + __v_35); let __v_37: G = (__v_31 + __v_36); let __v_38: G = (__v_29 + __v_37); let __v_39: G = (__v_27 + __v_38); let __v_40: G = (__v_25 + __v_39); let __v_41: G = (__v_23 + __v_40); let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = (__v_19 - __v_42); let __v_45: G = (__v_20 - __v_43); let __v_46: G = (__v_6 * __v_44); let __v_47: G = G::from_u64(7); let __v_48: G = (__v_7 * __v_45); let __v_49: G = (__v_47 * __v_48); let __v_50: G = (__v_46 + __v_49); let __v_51: G = (__v_6 * __v_45); let __v_52: G = (__v_7 * __v_44); let __v_53: G = (__v_51 + __v_52); let __v_54: G = (__v_4 + __v_50); let __v_55: G = (__v_5 + __v_53); let __v_56: G = (__v_6 * __v_2); let __v_57: G = (__v_7 * __v_3); let __v_58: G = (__v_47 * __v_57); let __v_59: G = (__v_56 + __v_58); let __v_60: G = (__v_6 * __v_3); let __v_61: G = (__v_7 * __v_2); let __v_62: G = (__v_60 + __v_61); let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __ret: [G; OUT_133] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_133(inp: [G; IN_133], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_133] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; match __v_18.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(256); let __v_23: G = __v_22 * __v_10; let __v_24: G = G::from_u64(65536); let __v_25: G = __v_24 * __v_11; let __v_26: G = G::from_u64(16777216); let __v_27: G = __v_26 * __v_12; let __v_28: G = G::from_u64(4294967296); let __v_29: G = __v_28 * __v_13; let __v_30: G = G::from_u64(1099511627776); let __v_31: G = __v_30 * __v_14; let __v_32: G = G::from_u64(281474976710656); let __v_33: G = __v_32 * __v_15; let __v_34: G = G::from_u64(72057594037927936); let __v_35: G = __v_34 * __v_16; let __v_36: G = __v_33 + __v_35; let __v_37: G = __v_31 + __v_36; let __v_38: G = __v_29 + __v_37; let __v_39: G = __v_27 + __v_38; let __v_40: G = __v_25 + __v_39; let __v_41: G = __v_23 + __v_40; let __v_42: G = __v_9 + __v_41; let __v_43: G = G::from_u64(0); let __v_44: G = __v_19 - __v_42; let __v_45: G = __v_20 - __v_43; let __v_46: G = __v_6 * __v_44; let __v_47: G = G::from_u64(7); let __v_48: G = __v_7 * __v_45; let __v_49: G = __v_47 * __v_48; let __v_50: G = __v_46 + __v_49; let __v_51: G = __v_6 * __v_45; let __v_52: G = __v_7 * __v_44; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_4 + __v_50; let __v_55: G = __v_5 + __v_53; let __v_56: G = __v_6 * __v_2; let __v_57: G = __v_7 * __v_3; let __v_58: G = __v_47 * __v_57; let __v_59: G = __v_56 + __v_58; let __v_60: G = __v_6 * __v_3; let __v_61: G = __v_7 * __v_2; let __v_62: G = __v_60 + __v_61; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __ret: [G; OUT_133] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_134: usize = 2; const IN_134: usize = 2; const OUT_134: usize = 1; -fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_134] = [__v_1]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_6: G = G::from_u8(__gb[0]); let __v_7: G = G::from_u8(__gb[1]); let __v_8: G = G::from_u8(__gb[2]); let __v_9: G = G::from_u8(__gb[3]); let __v_10: G = G::from_u8(__gb[4]); let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_14: G = G::from_u64(256); let __v_15: G = (__v_14 * __v_7); let __v_16: G = G::from_u64(65536); let __v_17: G = (__v_16 * __v_8); let __v_18: G = G::from_u64(16777216); let __v_19: G = (__v_18 * __v_9); let __v_20: G = G::from_u64(4294967296); let __v_21: G = (__v_20 * __v_10); let __v_22: G = G::from_u64(1099511627776); let __v_23: G = (__v_22 * __v_11); let __v_24: G = G::from_u64(281474976710656); let __v_25: G = (__v_24 * __v_12); let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = (__v_26 * __v_13); let __v_28: G = (__v_25 + __v_27); let __v_29: G = (__v_23 + __v_28); let __v_30: G = (__v_21 + __v_29); let __v_31: G = (__v_19 + __v_30); let __v_32: G = (__v_17 + __v_31); let __v_33: G = (__v_15 + __v_32); let __v_34: G = (__v_6 + __v_33); if (__v_34 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_35: G = G::from_u64(1020); let __v_36: G = (__v_13 - __v_35); let __v_37: G = (__v_12 + __v_36); let __v_38: G = (__v_11 + __v_37); let __v_39: G = (__v_10 + __v_38); let __v_40: G = G::from_bool((__v_39 == G::ZERO)); let __v_41: G = (__v_8 + __v_9); let __v_42: G = (__v_7 + __v_41); let __v_43: G = (__v_6 + __v_42); let __v_44: G = G::from_bool((__v_43 == G::ZERO)); let __v_45: G = G::from_u64(1); let __v_46: G = (__v_45 - __v_44); let __v_47: G = (__v_40 * __v_46); let __v_48: G = (__v_45 - __v_47); if (__v_48 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes(); let __v_49: G = G::from_u8(__gb[0]); let __v_50: G = G::from_u8(__gb[1]); let __v_51: G = G::from_u8(__gb[2]); let __v_52: G = G::from_u8(__gb[3]); let __v_53: G = G::from_u8(__gb[4]); let __v_54: G = G::from_u8(__gb[5]); let __v_55: G = G::from_u8(__gb[6]); let __v_56: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_57: G = (__v_14 * __v_50); let __v_58: G = (__v_16 * __v_51); let __v_59: G = (__v_18 * __v_52); let __v_60: G = (__v_20 * __v_53); let __v_61: G = (__v_22 * __v_54); let __v_62: G = (__v_24 * __v_55); let __v_63: G = (__v_26 * __v_56); let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_61 + __v_64); let __v_66: G = (__v_60 + __v_65); let __v_67: G = (__v_59 + __v_66); let __v_68: G = (__v_58 + __v_67); let __v_69: G = (__v_57 + __v_68); let __v_70: G = (__v_49 + __v_69); if (__v_70 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } let __v_71: G = (__v_56 - __v_35); let __v_72: G = (__v_55 + __v_71); let __v_73: G = (__v_54 + __v_72); let __v_74: G = (__v_53 + __v_73); let __v_75: G = G::from_bool((__v_74 == G::ZERO)); let __v_76: G = (__v_51 + __v_52); let __v_77: G = (__v_50 + __v_76); let __v_78: G = (__v_49 + __v_77); let __v_79: G = G::from_bool((__v_78 == G::ZERO)); let __v_80: G = (__v_45 - __v_79); let __v_81: G = (__v_75 * __v_80); let __v_82: G = (__v_45 - __v_81); if (__v_82 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, (&__args[..]))?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { (*(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134])) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_85]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_134] = [__v_1]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_6: G = G::from_u8(__gb[0]); let __v_7: G = G::from_u8(__gb[1]); let __v_8: G = G::from_u8(__gb[2]); let __v_9: G = G::from_u8(__gb[3]); let __v_10: G = G::from_u8(__gb[4]); let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_14: G = G::from_u64(256); let __v_15: G = __v_14 * __v_7; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_8; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_9; let __v_20: G = G::from_u64(4294967296); let __v_21: G = __v_20 * __v_10; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_11; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_12; let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = __v_26 * __v_13; let __v_28: G = __v_25 + __v_27; let __v_29: G = __v_23 + __v_28; let __v_30: G = __v_21 + __v_29; let __v_31: G = __v_19 + __v_30; let __v_32: G = __v_17 + __v_31; let __v_33: G = __v_15 + __v_32; let __v_34: G = __v_6 + __v_33; if (__v_34 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_35: G = G::from_u64(1020); let __v_36: G = __v_13 - __v_35; let __v_37: G = __v_12 + __v_36; let __v_38: G = __v_11 + __v_37; let __v_39: G = __v_10 + __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = __v_8 + __v_9; let __v_42: G = __v_7 + __v_41; let __v_43: G = __v_6 + __v_42; let __v_44: G = G::from_bool(__v_43 == G::ZERO); let __v_45: G = G::from_u64(1); let __v_46: G = __v_45 - __v_44; let __v_47: G = __v_40 * __v_46; let __v_48: G = __v_45 - __v_47; if (__v_48 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes(); let __v_49: G = G::from_u8(__gb[0]); let __v_50: G = G::from_u8(__gb[1]); let __v_51: G = G::from_u8(__gb[2]); let __v_52: G = G::from_u8(__gb[3]); let __v_53: G = G::from_u8(__gb[4]); let __v_54: G = G::from_u8(__gb[5]); let __v_55: G = G::from_u8(__gb[6]); let __v_56: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_57: G = __v_14 * __v_50; let __v_58: G = __v_16 * __v_51; let __v_59: G = __v_18 * __v_52; let __v_60: G = __v_20 * __v_53; let __v_61: G = __v_22 * __v_54; let __v_62: G = __v_24 * __v_55; let __v_63: G = __v_26 * __v_56; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_61 + __v_64; let __v_66: G = __v_60 + __v_65; let __v_67: G = __v_59 + __v_66; let __v_68: G = __v_58 + __v_67; let __v_69: G = __v_57 + __v_68; let __v_70: G = __v_49 + __v_69; if (__v_70 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } let __v_71: G = __v_56 - __v_35; let __v_72: G = __v_55 + __v_71; let __v_73: G = __v_54 + __v_72; let __v_74: G = __v_53 + __v_73; let __v_75: G = G::from_bool(__v_74 == G::ZERO); let __v_76: G = __v_51 + __v_52; let __v_77: G = __v_50 + __v_76; let __v_78: G = __v_49 + __v_77; let __v_79: G = G::from_bool(__v_78 == G::ZERO); let __v_80: G = __v_45 - __v_79; let __v_81: G = __v_75 * __v_80; let __v_82: G = __v_45 - __v_81; if (__v_82 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_85]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_135: usize = 2; const IN_135: usize = 2; const OUT_135: usize = 1; -fn aiur_fn_135(inp: [G; IN_135], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_135] = [__v_1]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, (&__args[..]))?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { (*(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134])) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_6]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_135(inp: [G; IN_135], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_135] = [__v_1]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_6]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_136: usize = 2; const IN_136: usize = 2; const OUT_136: usize = 1; -fn aiur_fn_136(inp: [G; IN_136], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_136] = [__v_1]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_6]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_136(inp: [G; IN_136], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_136] = [__v_1]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_6]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_137: usize = 3; const IN_137: usize = 3; const OUT_137: usize = 1; -fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_137] = [__v_2]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_3]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_137] = [__v_2]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_3]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_138: usize = 2; const IN_138: usize = 2; const OUT_138: usize = 1; -fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_138] = [__v_0]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_8]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_138] = [__v_0]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_8]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_139: usize = 10; const IN_139: usize = 10; const OUT_139: usize = 2; -fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_0, __v_11]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, (&__args[..]))?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { (*(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179])) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_139] = [__v_14, __v_15]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_0, __v_11]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_139] = [__v_14, __v_15]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_140: usize = 4; const IN_140: usize = 4; const OUT_140: usize = 2; -fn aiur_fn_140(inp: [G; IN_140], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_8, __v_0]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, (&__args[..]))?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { (*(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181])) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; let __v_32: G = __r_arr[12]; let __v_33: G = __r_arr[13]; let __v_34: G = __r_arr[14]; let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(256); let __v_41: G = (__v_40 * __v_21); let __v_42: G = G::from_u64(65536); let __v_43: G = (__v_42 * __v_22); let __v_44: G = G::from_u64(16777216); let __v_45: G = (__v_44 * __v_23); let __v_46: G = G::from_u64(4294967296); let __v_47: G = (__v_46 * __v_24); let __v_48: G = G::from_u64(1099511627776); let __v_49: G = (__v_48 * __v_25); let __v_50: G = G::from_u64(281474976710656); let __v_51: G = (__v_50 * __v_26); let __v_52: G = G::from_u64(72057594037927936); let __v_53: G = (__v_52 * __v_27); let __v_54: G = (__v_51 + __v_53); let __v_55: G = (__v_49 + __v_54); let __v_56: G = (__v_47 + __v_55); let __v_57: G = (__v_45 + __v_56); let __v_58: G = (__v_43 + __v_57); let __v_59: G = (__v_41 + __v_58); let __v_60: G = (__v_20 + __v_59); let __v_61: G = G::from_u64(0); let __v_62: G = (__v_40 * __v_29); let __v_63: G = (__v_42 * __v_30); let __v_64: G = (__v_44 * __v_31); let __v_65: G = (__v_46 * __v_32); let __v_66: G = (__v_48 * __v_33); let __v_67: G = (__v_50 * __v_34); let __v_68: G = (__v_52 * __v_35); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_66 + __v_69); let __v_71: G = (__v_65 + __v_70); let __v_72: G = (__v_64 + __v_71); let __v_73: G = (__v_63 + __v_72); let __v_74: G = (__v_62 + __v_73); let __v_75: G = (__v_28 + __v_74); let __v_76: G = { let __values: [G; 4] = [__v_61, __v_60, __v_75, __v_38]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_76, __v_39]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_140(inp: [G; IN_140], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_8, __v_0]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; let __v_32: G = __r_arr[12]; let __v_33: G = __r_arr[13]; let __v_34: G = __r_arr[14]; let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(256); let __v_41: G = __v_40 * __v_21; let __v_42: G = G::from_u64(65536); let __v_43: G = __v_42 * __v_22; let __v_44: G = G::from_u64(16777216); let __v_45: G = __v_44 * __v_23; let __v_46: G = G::from_u64(4294967296); let __v_47: G = __v_46 * __v_24; let __v_48: G = G::from_u64(1099511627776); let __v_49: G = __v_48 * __v_25; let __v_50: G = G::from_u64(281474976710656); let __v_51: G = __v_50 * __v_26; let __v_52: G = G::from_u64(72057594037927936); let __v_53: G = __v_52 * __v_27; let __v_54: G = __v_51 + __v_53; let __v_55: G = __v_49 + __v_54; let __v_56: G = __v_47 + __v_55; let __v_57: G = __v_45 + __v_56; let __v_58: G = __v_43 + __v_57; let __v_59: G = __v_41 + __v_58; let __v_60: G = __v_20 + __v_59; let __v_61: G = G::from_u64(0); let __v_62: G = __v_40 * __v_29; let __v_63: G = __v_42 * __v_30; let __v_64: G = __v_44 * __v_31; let __v_65: G = __v_46 * __v_32; let __v_66: G = __v_48 * __v_33; let __v_67: G = __v_50 * __v_34; let __v_68: G = __v_52 * __v_35; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_66 + __v_69; let __v_71: G = __v_65 + __v_70; let __v_72: G = __v_64 + __v_71; let __v_73: G = __v_63 + __v_72; let __v_74: G = __v_62 + __v_73; let __v_75: G = __v_28 + __v_74; let __v_76: G = { let __values: [G; 4] = [__v_61, __v_60, __v_75, __v_38]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_76, __v_39]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_141: usize = 5; const IN_141: usize = 5; const OUT_141: usize = 1; -fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_141] = [__v_5]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); let __v_8: G = G::from_bool((__v_7 == G::ZERO)); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 - __v_9); let __v_11: G = (__v_3 + __v_9); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_10, __v_11, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_12]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_141] = [__v_5]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __v_1 - __v_4; let __v_7: G = __v_5 + __v_6; let __v_8: G = G::from_bool(__v_7 == G::ZERO); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __v_11: G = __v_3 + __v_9; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_10, __v_11, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, &__args[..])?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_12]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_142: usize = 4; const IN_142: usize = 4; const OUT_142: usize = 1; -fn aiur_fn_142(inp: [G; IN_142], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 7] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_142] = [__v_5]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_142] = [__v_8]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_6, __v_6, __v_6, __v_9]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_142] = [__v_10]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_142(inp: [G; IN_142], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 7] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_142] = [__v_5]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, &__args[..])?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_3 - __v_6; let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_142] = [__v_8]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = __v_3 - __v_7; let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_6, __v_6, __v_6, __v_9]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_142] = [__v_10]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_143: usize = 8; const IN_143: usize = 8; const OUT_143: usize = 1; -fn aiur_fn_143(inp: [G; IN_143], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; match __v_8.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 7] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_143] = [__v_16]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { _ => { let __v_15: G = (__v_9 - __v_1); let __v_16: G = G::from_bool((__v_15 == G::ZERO)); match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = (__v_4 * __v_18); let __v_23: G = G::from_u64(7); let __v_24: G = (__v_5 * __v_19); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_22 + __v_25); let __v_27: G = (__v_4 * __v_19); let __v_28: G = (__v_5 * __v_18); let __v_29: G = (__v_27 + __v_28); let __v_30: G = (__v_12 + __v_26); let __v_31: G = (__v_13 + __v_29); let __v_32: G = { let __values: [G; 7] = [__v_17, __v_9, __v_20, __v_21, __v_30, __v_31, __v_14]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_143] = [__v_32]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_143] = [__v_19]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_143(inp: [G; IN_143], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; match __v_8.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 7] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_143] = [__v_16]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { _ => { let __v_15: G = __v_9 - __v_1; let __v_16: G = G::from_bool(__v_15 == G::ZERO); match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = __v_4 * __v_18; let __v_23: G = G::from_u64(7); let __v_24: G = __v_5 * __v_19; let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 + __v_25; let __v_27: G = __v_4 * __v_19; let __v_28: G = __v_5 * __v_18; let __v_29: G = __v_27 + __v_28; let __v_30: G = __v_12 + __v_26; let __v_31: G = __v_13 + __v_29; let __v_32: G = { let __values: [G; 7] = [__v_17, __v_9, __v_20, __v_21, __v_30, __v_31, __v_14]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_143] = [__v_32]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_143] = [__v_19]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_144: usize = 2; const IN_144: usize = 2; const OUT_144: usize = 1; -fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_144] = [__v_9]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_9: G = (__v_3 - __v_1); let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = (__v_6 - __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = (__v_7 - __v_11); let __v_15: G = G::from_bool((__v_14 == G::ZERO)); let __v_16: G = (__v_13 * __v_15); let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_144] = [__v_17]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_11]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_144] = [__v_9]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_9: G = __v_3 - __v_1; let __v_10: G = G::from_bool(__v_9 == G::ZERO); match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = __v_6 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_7 - __v_11; let __v_15: G = G::from_bool(__v_14 == G::ZERO); let __v_16: G = __v_13 * __v_15; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_144] = [__v_17]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, &__args[..])?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_11]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_145: usize = 2; const IN_145: usize = 2; const OUT_145: usize = 1; -fn aiur_fn_145(inp: [G; IN_145], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_145] = [__v_2]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_145] = [__v_2]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_145(inp: [G; IN_145], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_145] = [__v_2]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_145] = [__v_2]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_146: usize = 10; const IN_146: usize = 10; const OUT_146: usize = 1; -fn aiur_fn_146(inp: [G; IN_146], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__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_10: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7]; 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_11: G = __r_arr[0]; let __v_12: G = (__v_10 - __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_3 - __v_1); let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(308, (&__args[..]))?) { [G::ZERO; OUT_308] } else { let (__hash, __hit) = record.function_queries[308].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[308].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { (*(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308])) }; __ret }, _ => { aiur_fn_308::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(7); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16, __v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_18, __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 __v_22: G = (__v_17 * __v_21); let __v_23: G = G::from_u64(0); let __v_24: G = (__v_4 - __v_22); let __v_25: G = (__v_5 - __v_23); let __v_26: G = (__v_24 * __v_24); let __v_27: G = (__v_25 * __v_25); let __v_28: G = (__v_17 * __v_27); let __v_29: G = (__v_26 - __v_28); let __v_30: G = aiur::execute::g_inverse_value(__v_29); let __v_31: G = (__v_29 * __v_30); let __v_32: G = (__v_31 - __v_14); let __v_33: G = (__v_29 * __v_32); if (__v_33 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_34: G = (__v_30 * __v_32); if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_35: G = (__v_24 * __v_30); let __v_36: G = (__v_23 - __v_25); let __v_37: G = (__v_36 * __v_30); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_6, __v_7, __v_35, __v_37, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_38]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_146(inp: [G; IN_146], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__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_10: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7]; 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_11: G = __r_arr[0]; let __v_12: G = __v_10 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = __v_3 - __v_1; let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(308, &__args[..])?) { [G::ZERO; OUT_308] } else { let (__hash, __hit) = record.function_queries[308].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[308].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => { aiur_fn_308::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(7); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16, __v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_18, __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 __v_22: G = __v_17 * __v_21; let __v_23: G = G::from_u64(0); let __v_24: G = __v_4 - __v_22; let __v_25: G = __v_5 - __v_23; let __v_26: G = __v_24 * __v_24; let __v_27: G = __v_25 * __v_25; let __v_28: G = __v_17 * __v_27; let __v_29: G = __v_26 - __v_28; let __v_30: G = aiur::execute::g_inverse_value(__v_29); let __v_31: G = __v_29 * __v_30; let __v_32: G = __v_31 - __v_14; let __v_33: G = __v_29 * __v_32; if (__v_33 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_34: G = __v_30 * __v_32; if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_35: G = __v_24 * __v_30; let __v_36: G = __v_23 - __v_25; let __v_37: G = __v_36 * __v_30; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_6, __v_7, __v_35, __v_37, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_38]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_147: usize = 11; const IN_147: usize = 11; const OUT_147: usize = 1; -fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_8, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_5 * __v_15); let __v_17: G = G::from_u64(7); let __v_18: G = (__v_6 * __v_11); let __v_19: G = (__v_17 * __v_18); let __v_20: G = (__v_16 + __v_19); let __v_21: G = (__v_5 * __v_11); let __v_22: G = (__v_6 * __v_15); let __v_23: G = (__v_21 + __v_22); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_3, __v_1, __v_2, __v_20, __v_23, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_25]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_8, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __v_5 * __v_15; let __v_17: G = G::from_u64(7); let __v_18: G = __v_6 * __v_11; let __v_19: G = __v_17 * __v_18; let __v_20: G = __v_16 + __v_19; let __v_21: G = __v_5 * __v_11; let __v_22: G = __v_6 * __v_15; let __v_23: G = __v_21 + __v_22; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_3, __v_1, __v_2, __v_20, __v_23, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_25]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_148: usize = 13; const IN_148: usize = 13; const OUT_148: usize = 1; -fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_4]; 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_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_9, __v_4]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_10, __v_4]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_4 + __v_18); let __v_20: G = (__v_5 - __v_18); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, (&__args[..]))?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { (*(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148])) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_21]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_4]; 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_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_9, __v_4]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_10, __v_4]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = __v_4 + __v_18; let __v_20: G = __v_5 - __v_18; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, &__args[..])?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_21]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_149: usize = 13; const IN_149: usize = 13; const OUT_149: usize = 1; -fn aiur_fn_149(inp: [G; IN_149], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_149] = [__v_0]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_4]; 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_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_9, __v_4]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_10, __v_4]; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_16, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_4 + __v_20); let __v_22: G = (__v_5 - __v_20); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_149] = [__v_23]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_149(inp: [G; IN_149], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_149] = [__v_0]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_4]; 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_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_9, __v_4]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_10, __v_4]; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_16, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = __v_4 + __v_20; let __v_22: G = __v_5 - __v_20; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_149] = [__v_23]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_150: usize = 15; const IN_150: usize = 15; const OUT_150: usize = 1; -fn aiur_fn_150(inp: [G; IN_150], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_150] = [__v_0]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); let __v_19: G = (__v_5 - __v_17); let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_19, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_20]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_4]; 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_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_11, __v_6]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_12, __v_6]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); let __v_24: G = (__v_5 - __v_22); let __v_25: G = (__v_6 + __v_22); let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_24, __v_25, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_26]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_150(inp: [G; IN_150], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_150] = [__v_0]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = __v_4 + __v_17; let __v_19: G = __v_5 - __v_17; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_19, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_20]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_4]; 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_17: G = __r_arr[0]; let __v_18: G = __v_17 + __v_3; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_11, __v_6]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_12, __v_6]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = __v_4 + __v_22; let __v_24: G = __v_5 - __v_22; let __v_25: G = __v_6 + __v_22; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_24, __v_25, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_26]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_151: usize = 15; const IN_151: usize = 15; const OUT_151: usize = 1; -fn aiur_fn_151(inp: [G; IN_151], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_151] = [__v_0]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(294, (&__args[..]))?) { [G::ZERO; OUT_294] } else { let (__hash, __hit) = record.function_queries[294].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[294].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { (*(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294])) }; __ret }, _ => { aiur_fn_294::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4]; 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_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_6, __v_10, __v_5, __v_7, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, (&__args[..]))?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { (*(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154])) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, (&__args[..]))?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { (*(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153])) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_8, __v_9, __v_10, __v_22, __v_7, __v_22, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_25]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_151(inp: [G; IN_151], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_151] = [__v_0]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(294, &__args[..])?) { [G::ZERO; OUT_294] } else { let (__hash, __hit) = record.function_queries[294].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[294].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => { aiur_fn_294::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4]; 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_18: G = __r_arr[0]; let __v_19: G = __v_17 - __v_18; let __v_20: G = G::from_bool(__v_19 == G::ZERO); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_6, __v_10, __v_5, __v_7, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, &__args[..])?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_8, __v_9, __v_10, __v_22, __v_7, __v_22, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_25]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_152: usize = 4; const IN_152: usize = 4; const OUT_152: usize = 1; -fn aiur_fn_152(inp: [G; IN_152], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_152] = [__v_5]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = (__v_5 + __v_1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = (__v_3 + __v_7); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, (&__args[..]))?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { (*(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152])) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_152] = [__v_11]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_152(inp: [G; IN_152], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_152] = [__v_5]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __v_5 + __v_1; let __v_7: G = G::from_u64(1); let __v_8: G = __v_2 - __v_7; let __v_9: G = __v_3 + __v_7; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_152] = [__v_11]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_153: usize = 1; const IN_153: usize = 1; const OUT_153: usize = 1; -fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_153] = [__v_4]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, (&__args[..]))?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { (*(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153])) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_153] = [__v_4]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_153] = [__v_2]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_153] = [__v_4]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_153] = [__v_4]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_153] = [__v_2]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_154: usize = 5; const IN_154: usize = 5; const OUT_154: usize = 1; -fn aiur_fn_154(inp: [G; IN_154], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_154] = [__v_6]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); let __v_9: G = (__v_4 + __v_7); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, (&__args[..]))?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { (*(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154])) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_154] = [__v_10]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = (__v_8 + __v_1); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 - __v_10); let __v_12: G = (__v_4 + __v_10); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, (&__args[..]))?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { (*(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154])) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_7, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_154] = [__v_14]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_154(inp: [G; IN_154], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_154] = [__v_6]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_3 - __v_7; let __v_9: G = __v_4 + __v_7; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, &__args[..])?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_154] = [__v_10]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = __v_8 + __v_1; let __v_10: G = G::from_u64(1); let __v_11: G = __v_3 - __v_10; let __v_12: G = __v_4 + __v_10; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, &__args[..])?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_7, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_154] = [__v_14]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_155: usize = 5; const IN_155: usize = 5; const OUT_155: usize = 4; -fn aiur_fn_155(inp: [G; IN_155], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_155] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_155] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_155(inp: [G; IN_155], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_155] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_155] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_156: usize = 4; const IN_156: usize = 4; const OUT_156: usize = 1; -fn aiur_fn_156(inp: [G; IN_156], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); let __v_6: G = G::from_u8(__gb[2]); let __v_7: G = G::from_u8(__gb[3]); let __v_8: G = G::from_u8(__gb[4]); let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_12: G = G::from_u64(256); let __v_13: G = (__v_12 * __v_5); let __v_14: G = G::from_u64(65536); let __v_15: G = (__v_14 * __v_6); let __v_16: G = G::from_u64(16777216); let __v_17: G = (__v_16 * __v_7); let __v_18: G = G::from_u64(4294967296); let __v_19: G = (__v_18 * __v_8); let __v_20: G = G::from_u64(1099511627776); let __v_21: G = (__v_20 * __v_9); let __v_22: G = G::from_u64(281474976710656); let __v_23: G = (__v_22 * __v_10); let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = (__v_24 * __v_11); let __v_26: G = (__v_23 + __v_25); let __v_27: G = (__v_21 + __v_26); let __v_28: G = (__v_19 + __v_27); let __v_29: G = (__v_17 + __v_28); let __v_30: G = (__v_15 + __v_29); let __v_31: G = (__v_13 + __v_30); let __v_32: G = (__v_4 + __v_31); if (__v_32 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_33: G = G::from_u64(1020); let __v_34: G = (__v_11 - __v_33); let __v_35: G = (__v_10 + __v_34); let __v_36: G = (__v_9 + __v_35); let __v_37: G = (__v_8 + __v_36); let __v_38: G = G::from_bool((__v_37 == G::ZERO)); let __v_39: G = (__v_6 + __v_7); let __v_40: G = (__v_5 + __v_39); let __v_41: G = (__v_4 + __v_40); let __v_42: G = G::from_bool((__v_41 == G::ZERO)); let __v_43: G = G::from_u64(1); let __v_44: G = (__v_43 - __v_42); let __v_45: G = (__v_38 * __v_44); let __v_46: G = (__v_43 - __v_45); if (__v_46 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_47: G = G::from_u8(__gb[0]); let __v_48: G = G::from_u8(__gb[1]); let __v_49: G = G::from_u8(__gb[2]); let __v_50: G = G::from_u8(__gb[3]); let __v_51: G = G::from_u8(__gb[4]); let __v_52: G = G::from_u8(__gb[5]); let __v_53: G = G::from_u8(__gb[6]); let __v_54: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_47; let __vj = __v_48; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_55: G = (__v_12 * __v_48); let __v_56: G = (__v_14 * __v_49); let __v_57: G = (__v_16 * __v_50); let __v_58: G = (__v_18 * __v_51); let __v_59: G = (__v_20 * __v_52); let __v_60: G = (__v_22 * __v_53); let __v_61: G = (__v_24 * __v_54); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_58 + __v_63); let __v_65: G = (__v_57 + __v_64); let __v_66: G = (__v_56 + __v_65); let __v_67: G = (__v_55 + __v_66); let __v_68: G = (__v_47 + __v_67); if (__v_68 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_69: G = (__v_54 - __v_33); let __v_70: G = (__v_53 + __v_69); let __v_71: G = (__v_52 + __v_70); let __v_72: G = (__v_51 + __v_71); let __v_73: G = G::from_bool((__v_72 == G::ZERO)); let __v_74: G = (__v_49 + __v_50); let __v_75: G = (__v_48 + __v_74); let __v_76: G = (__v_47 + __v_75); let __v_77: G = G::from_bool((__v_76 == G::ZERO)); let __v_78: G = (__v_43 - __v_77); let __v_79: G = (__v_73 * __v_78); let __v_80: G = (__v_43 - __v_79); if (__v_80 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_81: G = G::from_u8(__gb[0]); let __v_82: G = G::from_u8(__gb[1]); let __v_83: G = G::from_u8(__gb[2]); let __v_84: G = G::from_u8(__gb[3]); let __v_85: G = G::from_u8(__gb[4]); let __v_86: G = G::from_u8(__gb[5]); let __v_87: G = G::from_u8(__gb[6]); let __v_88: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_81; let __vj = __v_82; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_83; let __vj = __v_84; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_89: G = (__v_12 * __v_82); let __v_90: G = (__v_14 * __v_83); let __v_91: G = (__v_16 * __v_84); let __v_92: G = (__v_18 * __v_85); let __v_93: G = (__v_20 * __v_86); let __v_94: G = (__v_22 * __v_87); let __v_95: G = (__v_24 * __v_88); let __v_96: G = (__v_94 + __v_95); let __v_97: G = (__v_93 + __v_96); let __v_98: G = (__v_92 + __v_97); let __v_99: G = (__v_91 + __v_98); let __v_100: G = (__v_90 + __v_99); let __v_101: G = (__v_89 + __v_100); let __v_102: G = (__v_81 + __v_101); if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_103: G = (__v_88 - __v_33); let __v_104: G = (__v_87 + __v_103); let __v_105: G = (__v_86 + __v_104); let __v_106: G = (__v_85 + __v_105); let __v_107: G = G::from_bool((__v_106 == G::ZERO)); let __v_108: G = (__v_83 + __v_84); let __v_109: G = (__v_82 + __v_108); let __v_110: G = (__v_81 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); let __v_112: G = (__v_43 - __v_111); let __v_113: G = (__v_107 * __v_112); let __v_114: G = (__v_43 - __v_113); if (__v_114 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_115: G = G::from_u8(__gb[0]); let __v_116: G = G::from_u8(__gb[1]); let __v_117: G = G::from_u8(__gb[2]); let __v_118: G = G::from_u8(__gb[3]); let __v_119: G = G::from_u8(__gb[4]); let __v_120: G = G::from_u8(__gb[5]); let __v_121: G = G::from_u8(__gb[6]); let __v_122: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_115; let __vj = __v_116; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_117; let __vj = __v_118; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_123: G = (__v_12 * __v_116); let __v_124: G = (__v_14 * __v_117); let __v_125: G = (__v_16 * __v_118); let __v_126: G = (__v_18 * __v_119); let __v_127: G = (__v_20 * __v_120); let __v_128: G = (__v_22 * __v_121); let __v_129: G = (__v_24 * __v_122); let __v_130: G = (__v_128 + __v_129); let __v_131: G = (__v_127 + __v_130); let __v_132: G = (__v_126 + __v_131); let __v_133: G = (__v_125 + __v_132); let __v_134: G = (__v_124 + __v_133); let __v_135: G = (__v_123 + __v_134); let __v_136: G = (__v_115 + __v_135); if (__v_136 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_137: G = (__v_122 - __v_33); let __v_138: G = (__v_121 + __v_137); let __v_139: G = (__v_120 + __v_138); let __v_140: G = (__v_119 + __v_139); let __v_141: G = G::from_bool((__v_140 == G::ZERO)); let __v_142: G = (__v_117 + __v_118); let __v_143: G = (__v_116 + __v_142); let __v_144: G = (__v_115 + __v_143); let __v_145: G = G::from_bool((__v_144 == G::ZERO)); let __v_146: G = (__v_43 - __v_145); let __v_147: G = (__v_141 * __v_146); let __v_148: G = (__v_43 - __v_147); if (__v_148 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __v_149: G = G::from_u64(0); let __v_150: G = { let __values: [G; 10] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_151: G = { let __values: [G; 10] = [__v_149, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_150]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_152: G = { let __values: [G; 10] = [__v_149, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_151]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_153: G = { let __values: [G; 10] = [__v_149, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_152]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_154: G = { let __values: [G; 10] = [__v_149, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_153]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_156] = [__v_154]; record.function_queries[156].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_156(inp: [G; IN_156], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); let __v_6: G = G::from_u8(__gb[2]); let __v_7: G = G::from_u8(__gb[3]); let __v_8: G = G::from_u8(__gb[4]); let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_12: G = G::from_u64(256); let __v_13: G = __v_12 * __v_5; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_6; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_7; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_8; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_9; let __v_22: G = G::from_u64(281474976710656); let __v_23: G = __v_22 * __v_10; let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = __v_24 * __v_11; let __v_26: G = __v_23 + __v_25; let __v_27: G = __v_21 + __v_26; let __v_28: G = __v_19 + __v_27; let __v_29: G = __v_17 + __v_28; let __v_30: G = __v_15 + __v_29; let __v_31: G = __v_13 + __v_30; let __v_32: G = __v_4 + __v_31; if (__v_32 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_33: G = G::from_u64(1020); let __v_34: G = __v_11 - __v_33; let __v_35: G = __v_10 + __v_34; let __v_36: G = __v_9 + __v_35; let __v_37: G = __v_8 + __v_36; let __v_38: G = G::from_bool(__v_37 == G::ZERO); let __v_39: G = __v_6 + __v_7; let __v_40: G = __v_5 + __v_39; let __v_41: G = __v_4 + __v_40; let __v_42: G = G::from_bool(__v_41 == G::ZERO); let __v_43: G = G::from_u64(1); let __v_44: G = __v_43 - __v_42; let __v_45: G = __v_38 * __v_44; let __v_46: G = __v_43 - __v_45; if (__v_46 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_47: G = G::from_u8(__gb[0]); let __v_48: G = G::from_u8(__gb[1]); let __v_49: G = G::from_u8(__gb[2]); let __v_50: G = G::from_u8(__gb[3]); let __v_51: G = G::from_u8(__gb[4]); let __v_52: G = G::from_u8(__gb[5]); let __v_53: G = G::from_u8(__gb[6]); let __v_54: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_47; let __vj = __v_48; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_55: G = __v_12 * __v_48; let __v_56: G = __v_14 * __v_49; let __v_57: G = __v_16 * __v_50; let __v_58: G = __v_18 * __v_51; let __v_59: G = __v_20 * __v_52; let __v_60: G = __v_22 * __v_53; let __v_61: G = __v_24 * __v_54; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_59 + __v_62; let __v_64: G = __v_58 + __v_63; let __v_65: G = __v_57 + __v_64; let __v_66: G = __v_56 + __v_65; let __v_67: G = __v_55 + __v_66; let __v_68: G = __v_47 + __v_67; if (__v_68 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_69: G = __v_54 - __v_33; let __v_70: G = __v_53 + __v_69; let __v_71: G = __v_52 + __v_70; let __v_72: G = __v_51 + __v_71; let __v_73: G = G::from_bool(__v_72 == G::ZERO); let __v_74: G = __v_49 + __v_50; let __v_75: G = __v_48 + __v_74; let __v_76: G = __v_47 + __v_75; let __v_77: G = G::from_bool(__v_76 == G::ZERO); let __v_78: G = __v_43 - __v_77; let __v_79: G = __v_73 * __v_78; let __v_80: G = __v_43 - __v_79; if (__v_80 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_81: G = G::from_u8(__gb[0]); let __v_82: G = G::from_u8(__gb[1]); let __v_83: G = G::from_u8(__gb[2]); let __v_84: G = G::from_u8(__gb[3]); let __v_85: G = G::from_u8(__gb[4]); let __v_86: G = G::from_u8(__gb[5]); let __v_87: G = G::from_u8(__gb[6]); let __v_88: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_81; let __vj = __v_82; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_83; let __vj = __v_84; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_89: G = __v_12 * __v_82; let __v_90: G = __v_14 * __v_83; let __v_91: G = __v_16 * __v_84; let __v_92: G = __v_18 * __v_85; let __v_93: G = __v_20 * __v_86; let __v_94: G = __v_22 * __v_87; let __v_95: G = __v_24 * __v_88; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_93 + __v_96; let __v_98: G = __v_92 + __v_97; let __v_99: G = __v_91 + __v_98; let __v_100: G = __v_90 + __v_99; let __v_101: G = __v_89 + __v_100; let __v_102: G = __v_81 + __v_101; if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_103: G = __v_88 - __v_33; let __v_104: G = __v_87 + __v_103; let __v_105: G = __v_86 + __v_104; let __v_106: G = __v_85 + __v_105; let __v_107: G = G::from_bool(__v_106 == G::ZERO); let __v_108: G = __v_83 + __v_84; let __v_109: G = __v_82 + __v_108; let __v_110: G = __v_81 + __v_109; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_43 - __v_111; let __v_113: G = __v_107 * __v_112; let __v_114: G = __v_43 - __v_113; if (__v_114 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_115: G = G::from_u8(__gb[0]); let __v_116: G = G::from_u8(__gb[1]); let __v_117: G = G::from_u8(__gb[2]); let __v_118: G = G::from_u8(__gb[3]); let __v_119: G = G::from_u8(__gb[4]); let __v_120: G = G::from_u8(__gb[5]); let __v_121: G = G::from_u8(__gb[6]); let __v_122: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_115; let __vj = __v_116; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_117; let __vj = __v_118; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_123: G = __v_12 * __v_116; let __v_124: G = __v_14 * __v_117; let __v_125: G = __v_16 * __v_118; let __v_126: G = __v_18 * __v_119; let __v_127: G = __v_20 * __v_120; let __v_128: G = __v_22 * __v_121; let __v_129: G = __v_24 * __v_122; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_127 + __v_130; let __v_132: G = __v_126 + __v_131; let __v_133: G = __v_125 + __v_132; let __v_134: G = __v_124 + __v_133; let __v_135: G = __v_123 + __v_134; let __v_136: G = __v_115 + __v_135; if (__v_136 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_137: G = __v_122 - __v_33; let __v_138: G = __v_121 + __v_137; let __v_139: G = __v_120 + __v_138; let __v_140: G = __v_119 + __v_139; let __v_141: G = G::from_bool(__v_140 == G::ZERO); let __v_142: G = __v_117 + __v_118; let __v_143: G = __v_116 + __v_142; let __v_144: G = __v_115 + __v_143; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_43 - __v_145; let __v_147: G = __v_141 * __v_146; let __v_148: G = __v_43 - __v_147; if (__v_148 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __v_149: G = G::from_u64(0); let __v_150: G = { let __values: [G; 10] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_151: G = { let __values: [G; 10] = [__v_149, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_150]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_152: G = { let __values: [G; 10] = [__v_149, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_151]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_153: G = { let __values: [G; 10] = [__v_149, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_152]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_154: G = { let __values: [G; 10] = [__v_149, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_153]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_156] = [__v_154]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_157: usize = 6; const IN_157: usize = 6; const OUT_157: usize = 3; -fn aiur_fn_157(inp: [G; IN_157], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_157] = [__v_0, __v_1, __v_5]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_13: G = (__v_7 - __v_2); let __v_14: G = G::from_bool((__v_13 == G::ZERO)); match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); let __v_19: G = G::from_u64(7); let __v_20: G = (__v_17 * __v_11); let __v_21: G = (__v_19 * __v_20); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_16 * __v_11); let __v_24: G = (__v_17 * __v_10); let __v_25: G = (__v_23 + __v_24); let __v_26: G = (__v_0 + __v_22); let __v_27: G = (__v_1 + __v_25); let __ret: [G; OUT_157] = [__v_26, __v_27, __v_12]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_157] = [__v_0, __v_1, __v_5]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +fn aiur_fn_157(inp: [G; IN_157], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_157] = [__v_0, __v_1, __v_5]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_13: G = __v_7 - __v_2; let __v_14: G = G::from_bool(__v_13 == G::ZERO); match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __v_16 * __v_10; let __v_19: G = G::from_u64(7); let __v_20: G = __v_17 * __v_11; let __v_21: G = __v_19 * __v_20; let __v_22: G = __v_18 + __v_21; let __v_23: G = __v_16 * __v_11; let __v_24: G = __v_17 * __v_10; let __v_25: G = __v_23 + __v_24; let __v_26: G = __v_0 + __v_22; let __v_27: G = __v_1 + __v_25; let __ret: [G; OUT_157] = [__v_26, __v_27, __v_12]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_157] = [__v_0, __v_1, __v_5]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_158: usize = 9; const IN_158: usize = 9; const OUT_158: usize = 3; -fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { let __v_13: G = (__v_6 - __v_8); let __v_14: G = G::from_bool((__v_13 == G::ZERO)); let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7]; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __v_18: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_0, __v_1, __v_18]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_11]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_6 - __v_25); let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_11, __v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_23.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_0, __v_1, __v_28, __v_29]; }, _ => { break '__mc_0 [__v_28, __v_29, __v_0, __v_1]; }, } }; let __v_30: G = __mc_out___mc_0[0]; let __v_31: G = __mc_out___mc_0[1]; let __v_32: G = __mc_out___mc_0[2]; let __v_33: G = __mc_out___mc_0[3]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_36, __v_37, __v_16, __v_19, __v_12, __v_24, __v_26, __v_38, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); let __v_42: G = G::from_u8(__gb[0]); let __v_43: G = G::from_u8(__gb[1]); let __v_44: G = G::from_u8(__gb[2]); let __v_45: G = G::from_u8(__gb[3]); let __v_46: G = G::from_u8(__gb[4]); let __v_47: G = G::from_u8(__gb[5]); let __v_48: G = G::from_u8(__gb[6]); let __v_49: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_48; let __vj = __v_49; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_50: G = G::from_u64(256); let __v_51: G = (__v_50 * __v_43); let __v_52: G = G::from_u64(65536); let __v_53: G = (__v_52 * __v_44); let __v_54: G = G::from_u64(16777216); let __v_55: G = (__v_54 * __v_45); let __v_56: G = G::from_u64(4294967296); let __v_57: G = (__v_56 * __v_46); let __v_58: G = G::from_u64(1099511627776); let __v_59: G = (__v_58 * __v_47); let __v_60: G = G::from_u64(281474976710656); let __v_61: G = (__v_60 * __v_48); let __v_62: G = G::from_u64(72057594037927936); let __v_63: G = (__v_62 * __v_49); let __v_64: G = (__v_61 + __v_63); let __v_65: G = (__v_59 + __v_64); let __v_66: G = (__v_57 + __v_65); let __v_67: G = (__v_55 + __v_66); let __v_68: G = (__v_53 + __v_67); let __v_69: G = (__v_51 + __v_68); let __v_70: G = (__v_42 + __v_69); if (__v_70 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __v_71: G = G::from_u64(1020); let __v_72: G = (__v_49 - __v_71); let __v_73: G = (__v_48 + __v_72); let __v_74: G = (__v_47 + __v_73); let __v_75: G = (__v_46 + __v_74); let __v_76: G = G::from_bool((__v_75 == G::ZERO)); let __v_77: G = (__v_44 + __v_45); let __v_78: G = (__v_43 + __v_77); let __v_79: G = (__v_42 + __v_78); let __v_80: G = G::from_bool((__v_79 == G::ZERO)); let __v_81: G = G::from_u64(1); let __v_82: G = (__v_81 - __v_80); let __v_83: G = (__v_76 * __v_82); let __v_84: G = (__v_81 - __v_83); if (__v_84 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); let __v_85: G = G::from_u8(__gb[0]); let __v_86: G = G::from_u8(__gb[1]); let __v_87: G = G::from_u8(__gb[2]); let __v_88: G = G::from_u8(__gb[3]); let __v_89: G = G::from_u8(__gb[4]); let __v_90: G = G::from_u8(__gb[5]); let __v_91: G = G::from_u8(__gb[6]); let __v_92: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_93: G = (__v_50 * __v_86); let __v_94: G = (__v_52 * __v_87); let __v_95: G = (__v_54 * __v_88); let __v_96: G = (__v_56 * __v_89); let __v_97: G = (__v_58 * __v_90); let __v_98: G = (__v_60 * __v_91); let __v_99: G = (__v_62 * __v_92); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_97 + __v_100); let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_95 + __v_102); let __v_104: G = (__v_94 + __v_103); let __v_105: G = (__v_93 + __v_104); let __v_106: G = (__v_85 + __v_105); if (__v_106 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_106.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_107: G = (__v_92 - __v_71); let __v_108: G = (__v_91 + __v_107); let __v_109: G = (__v_90 + __v_108); let __v_110: G = (__v_89 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); let __v_112: G = (__v_87 + __v_88); let __v_113: G = (__v_86 + __v_112); let __v_114: G = (__v_85 + __v_113); let __v_115: G = G::from_bool((__v_114 == G::ZERO)); let __v_116: G = (__v_81 - __v_115); let __v_117: G = (__v_111 * __v_116); let __v_118: G = (__v_81 - __v_117); if (__v_118 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_119: G = G::from_u8(__gb[0]); let __v_120: G = G::from_u8(__gb[1]); let __v_121: G = G::from_u8(__gb[2]); let __v_122: G = G::from_u8(__gb[3]); let __v_123: G = G::from_u8(__gb[4]); let __v_124: G = G::from_u8(__gb[5]); let __v_125: G = G::from_u8(__gb[6]); let __v_126: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_123; let __vj = __v_124; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_125; let __vj = __v_126; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_127: G = (__v_50 * __v_120); let __v_128: G = (__v_52 * __v_121); let __v_129: G = (__v_54 * __v_122); let __v_130: G = (__v_56 * __v_123); let __v_131: G = (__v_58 * __v_124); let __v_132: G = (__v_60 * __v_125); let __v_133: G = (__v_62 * __v_126); let __v_134: G = (__v_132 + __v_133); let __v_135: G = (__v_131 + __v_134); let __v_136: G = (__v_130 + __v_135); let __v_137: G = (__v_129 + __v_136); let __v_138: G = (__v_128 + __v_137); let __v_139: G = (__v_127 + __v_138); let __v_140: G = (__v_119 + __v_139); if (__v_140 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_141: G = (__v_126 - __v_71); let __v_142: G = (__v_125 + __v_141); let __v_143: G = (__v_124 + __v_142); let __v_144: G = (__v_123 + __v_143); let __v_145: G = G::from_bool((__v_144 == G::ZERO)); let __v_146: G = (__v_121 + __v_122); let __v_147: G = (__v_120 + __v_146); let __v_148: G = (__v_119 + __v_147); let __v_149: G = G::from_bool((__v_148 == G::ZERO)); let __v_150: G = (__v_81 - __v_149); let __v_151: G = (__v_145 * __v_150); let __v_152: G = (__v_81 - __v_151); if (__v_152 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_153: G = G::from_u8(__gb[0]); let __v_154: G = G::from_u8(__gb[1]); let __v_155: G = G::from_u8(__gb[2]); let __v_156: G = G::from_u8(__gb[3]); let __v_157: G = G::from_u8(__gb[4]); let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_161: G = (__v_50 * __v_154); let __v_162: G = (__v_52 * __v_155); let __v_163: G = (__v_54 * __v_156); let __v_164: G = (__v_56 * __v_157); let __v_165: G = (__v_58 * __v_158); let __v_166: G = (__v_60 * __v_159); let __v_167: G = (__v_62 * __v_160); let __v_168: G = (__v_166 + __v_167); let __v_169: G = (__v_165 + __v_168); let __v_170: G = (__v_164 + __v_169); let __v_171: G = (__v_163 + __v_170); let __v_172: G = (__v_162 + __v_171); let __v_173: G = (__v_161 + __v_172); let __v_174: G = (__v_153 + __v_173); if (__v_174 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None }); } let __v_175: G = (__v_160 - __v_71); let __v_176: G = (__v_159 + __v_175); let __v_177: G = (__v_158 + __v_176); let __v_178: G = (__v_157 + __v_177); let __v_179: G = G::from_bool((__v_178 == G::ZERO)); let __v_180: G = (__v_155 + __v_156); let __v_181: G = (__v_154 + __v_180); let __v_182: G = (__v_153 + __v_181); let __v_183: G = G::from_bool((__v_182 == G::ZERO)); let __v_184: G = (__v_81 - __v_183); let __v_185: G = (__v_179 * __v_184); let __v_186: G = (__v_81 - __v_185); if (__v_186 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __v_187: G = G::from_u64(0); let __v_188: G = { let __values: [G; 10] = [__v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_189: G = { let __values: [G; 10] = [__v_187, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_188]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_190: G = { let __values: [G; 10] = [__v_187, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_189]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_191: G = { let __values: [G; 10] = [__v_187, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_190]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_192: G = { let __values: [G; 10] = [__v_187, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_191]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_193: G = { let __values: [G; 3] = [__v_187, __v_192, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_39, __v_40, __v_193]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { let __v_13: G = __v_6 - __v_8; let __v_14: G = G::from_bool(__v_13 == G::ZERO); let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7]; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __v_18: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_0, __v_1, __v_18]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_11]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = __v_6 - __v_25; let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_11, __v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_23.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_0, __v_1, __v_28, __v_29]; }, _ => { break '__mc_0 [__v_28, __v_29, __v_0, __v_1]; }, } }; let __v_30: G = __mc_out___mc_0[0]; let __v_31: G = __mc_out___mc_0[1]; let __v_32: G = __mc_out___mc_0[2]; let __v_33: G = __mc_out___mc_0[3]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_36, __v_37, __v_16, __v_19, __v_12, __v_24, __v_26, __v_38, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); let __v_42: G = G::from_u8(__gb[0]); let __v_43: G = G::from_u8(__gb[1]); let __v_44: G = G::from_u8(__gb[2]); let __v_45: G = G::from_u8(__gb[3]); let __v_46: G = G::from_u8(__gb[4]); let __v_47: G = G::from_u8(__gb[5]); let __v_48: G = G::from_u8(__gb[6]); let __v_49: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_48; let __vj = __v_49; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_50: G = G::from_u64(256); let __v_51: G = __v_50 * __v_43; let __v_52: G = G::from_u64(65536); let __v_53: G = __v_52 * __v_44; let __v_54: G = G::from_u64(16777216); let __v_55: G = __v_54 * __v_45; let __v_56: G = G::from_u64(4294967296); let __v_57: G = __v_56 * __v_46; let __v_58: G = G::from_u64(1099511627776); let __v_59: G = __v_58 * __v_47; let __v_60: G = G::from_u64(281474976710656); let __v_61: G = __v_60 * __v_48; let __v_62: G = G::from_u64(72057594037927936); let __v_63: G = __v_62 * __v_49; let __v_64: G = __v_61 + __v_63; let __v_65: G = __v_59 + __v_64; let __v_66: G = __v_57 + __v_65; let __v_67: G = __v_55 + __v_66; let __v_68: G = __v_53 + __v_67; let __v_69: G = __v_51 + __v_68; let __v_70: G = __v_42 + __v_69; if (__v_70 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __v_71: G = G::from_u64(1020); let __v_72: G = __v_49 - __v_71; let __v_73: G = __v_48 + __v_72; let __v_74: G = __v_47 + __v_73; let __v_75: G = __v_46 + __v_74; let __v_76: G = G::from_bool(__v_75 == G::ZERO); let __v_77: G = __v_44 + __v_45; let __v_78: G = __v_43 + __v_77; let __v_79: G = __v_42 + __v_78; let __v_80: G = G::from_bool(__v_79 == G::ZERO); let __v_81: G = G::from_u64(1); let __v_82: G = __v_81 - __v_80; let __v_83: G = __v_76 * __v_82; let __v_84: G = __v_81 - __v_83; if (__v_84 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); let __v_85: G = G::from_u8(__gb[0]); let __v_86: G = G::from_u8(__gb[1]); let __v_87: G = G::from_u8(__gb[2]); let __v_88: G = G::from_u8(__gb[3]); let __v_89: G = G::from_u8(__gb[4]); let __v_90: G = G::from_u8(__gb[5]); let __v_91: G = G::from_u8(__gb[6]); let __v_92: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_93: G = __v_50 * __v_86; let __v_94: G = __v_52 * __v_87; let __v_95: G = __v_54 * __v_88; let __v_96: G = __v_56 * __v_89; let __v_97: G = __v_58 * __v_90; let __v_98: G = __v_60 * __v_91; let __v_99: G = __v_62 * __v_92; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_97 + __v_100; let __v_102: G = __v_96 + __v_101; let __v_103: G = __v_95 + __v_102; let __v_104: G = __v_94 + __v_103; let __v_105: G = __v_93 + __v_104; let __v_106: G = __v_85 + __v_105; if (__v_106 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_106.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_107: G = __v_92 - __v_71; let __v_108: G = __v_91 + __v_107; let __v_109: G = __v_90 + __v_108; let __v_110: G = __v_89 + __v_109; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_87 + __v_88; let __v_113: G = __v_86 + __v_112; let __v_114: G = __v_85 + __v_113; let __v_115: G = G::from_bool(__v_114 == G::ZERO); let __v_116: G = __v_81 - __v_115; let __v_117: G = __v_111 * __v_116; let __v_118: G = __v_81 - __v_117; if (__v_118 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_119: G = G::from_u8(__gb[0]); let __v_120: G = G::from_u8(__gb[1]); let __v_121: G = G::from_u8(__gb[2]); let __v_122: G = G::from_u8(__gb[3]); let __v_123: G = G::from_u8(__gb[4]); let __v_124: G = G::from_u8(__gb[5]); let __v_125: G = G::from_u8(__gb[6]); let __v_126: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_123; let __vj = __v_124; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_125; let __vj = __v_126; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_127: G = __v_50 * __v_120; let __v_128: G = __v_52 * __v_121; let __v_129: G = __v_54 * __v_122; let __v_130: G = __v_56 * __v_123; let __v_131: G = __v_58 * __v_124; let __v_132: G = __v_60 * __v_125; let __v_133: G = __v_62 * __v_126; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_131 + __v_134; let __v_136: G = __v_130 + __v_135; let __v_137: G = __v_129 + __v_136; let __v_138: G = __v_128 + __v_137; let __v_139: G = __v_127 + __v_138; let __v_140: G = __v_119 + __v_139; if (__v_140 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_141: G = __v_126 - __v_71; let __v_142: G = __v_125 + __v_141; let __v_143: G = __v_124 + __v_142; let __v_144: G = __v_123 + __v_143; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_121 + __v_122; let __v_147: G = __v_120 + __v_146; let __v_148: G = __v_119 + __v_147; let __v_149: G = G::from_bool(__v_148 == G::ZERO); let __v_150: G = __v_81 - __v_149; let __v_151: G = __v_145 * __v_150; let __v_152: G = __v_81 - __v_151; if (__v_152 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_153: G = G::from_u8(__gb[0]); let __v_154: G = G::from_u8(__gb[1]); let __v_155: G = G::from_u8(__gb[2]); let __v_156: G = G::from_u8(__gb[3]); let __v_157: G = G::from_u8(__gb[4]); let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_161: G = __v_50 * __v_154; let __v_162: G = __v_52 * __v_155; let __v_163: G = __v_54 * __v_156; let __v_164: G = __v_56 * __v_157; let __v_165: G = __v_58 * __v_158; let __v_166: G = __v_60 * __v_159; let __v_167: G = __v_62 * __v_160; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_165 + __v_168; let __v_170: G = __v_164 + __v_169; let __v_171: G = __v_163 + __v_170; let __v_172: G = __v_162 + __v_171; let __v_173: G = __v_161 + __v_172; let __v_174: G = __v_153 + __v_173; if (__v_174 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None }); } let __v_175: G = __v_160 - __v_71; let __v_176: G = __v_159 + __v_175; let __v_177: G = __v_158 + __v_176; let __v_178: G = __v_157 + __v_177; let __v_179: G = G::from_bool(__v_178 == G::ZERO); let __v_180: G = __v_155 + __v_156; let __v_181: G = __v_154 + __v_180; let __v_182: G = __v_153 + __v_181; let __v_183: G = G::from_bool(__v_182 == G::ZERO); let __v_184: G = __v_81 - __v_183; let __v_185: G = __v_179 * __v_184; let __v_186: G = __v_81 - __v_185; if (__v_186 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __v_187: G = G::from_u64(0); let __v_188: G = { let __values: [G; 10] = [__v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_189: G = { let __values: [G; 10] = [__v_187, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_188]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_190: G = { let __values: [G; 10] = [__v_187, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_189]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_191: G = { let __values: [G; 10] = [__v_187, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_190]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_192: G = { let __values: [G; 10] = [__v_187, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_191]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_193: G = { let __values: [G; 3] = [__v_187, __v_192, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_39, __v_40, __v_193]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_159: usize = 25; const IN_159: usize = 25; const OUT_159: usize = 1; -fn aiur_fn_159(inp: [G; IN_159], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; 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 __v_26: G = (__v_25 - __v_24); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_30 + __v_31); let __v_33: G = (__v_29 - __v_32); let __v_34: G = G::from_bool((__v_33 == G::ZERO)); if (__v_34 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, (&__args[..]))?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { (*(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152])) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_36]; 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_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: G = (__v_39 - __v_18); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_43: G = G::from_u64(0); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_35, __v_0, __v_20, __v_19, __v_43, __v_18, __v_15, __v_16, __v_17, __v_38, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, (&__args[..]))?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { (*(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148])) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_42]; 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_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_45]; 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_46: G = __r_arr[0]; let __v_47: G = (__v_46 - __v_18); let __v_48: G = G::from_bool((__v_47 == G::ZERO)); let __v_49: G = G::from_u64(1); if (__v_48 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None }); } let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_44, __v_0, __v_20, __v_19, __v_50, __v_18, __v_15, __v_16, __v_17, __v_45, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, (&__args[..]))?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { (*(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148])) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_52]; 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_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_53]; 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_54: G = __r_arr[0]; let __v_55: G = (__v_54 - __v_18); let __v_56: G = G::from_bool((__v_55 == G::ZERO)); let __v_57: G = G::from_u64(1); if (__v_56 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None }); } let __v_58: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_51, __v_0, __v_20, __v_19, __v_58, __v_18, __v_15, __v_16, __v_17, __v_53, __v_7, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_59, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_60, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_62: G = __loaded[0]; let __v_63: G = __loaded[1]; let __v_64: G = __loaded[2]; let __v_65: G = __loaded[3]; let __v_66: G = __loaded[4]; let __v_67: G = __loaded[5]; let __v_68: G = __loaded[6]; match __v_62.as_canonical_u64() { 0u64 => { match __v_63.as_canonical_u64() { _ => { let __v_69: G = (__v_63 - __v_20); let __v_70: G = G::from_bool((__v_69 == G::ZERO)); let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_66, __v_67, __v_21, __v_22, __v_2, __v_0, __v_20, __v_68, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_23, __v_75]; 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_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = (__v_76 - __v_72); let __v_79: G = G::from_bool((__v_78 == G::ZERO)); let __v_80: G = (__v_77 - __v_73); let __v_81: G = G::from_bool((__v_80 == G::ZERO)); let __v_82: G = (__v_79 * __v_81); if (__v_82 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_159] = [__v_74]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } +fn aiur_fn_159(inp: [G; IN_159], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; 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 __v_26: G = __v_25 - __v_24; let __v_27: G = G::from_bool(__v_26 == G::ZERO); let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __v_30 + __v_31; let __v_33: G = __v_29 - __v_32; let __v_34: G = G::from_bool(__v_33 == G::ZERO); if (__v_34 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_36]; 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_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __v_39 - __v_18; let __v_41: G = G::from_bool(__v_40 == G::ZERO); let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_43: G = G::from_u64(0); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_35, __v_0, __v_20, __v_19, __v_43, __v_18, __v_15, __v_16, __v_17, __v_38, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, &__args[..])?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_42]; 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_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_45]; 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_46: G = __r_arr[0]; let __v_47: G = __v_46 - __v_18; let __v_48: G = G::from_bool(__v_47 == G::ZERO); let __v_49: G = G::from_u64(1); if (__v_48 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None }); } let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_44, __v_0, __v_20, __v_19, __v_50, __v_18, __v_15, __v_16, __v_17, __v_45, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, &__args[..])?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_52]; 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_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_53]; 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_54: G = __r_arr[0]; let __v_55: G = __v_54 - __v_18; let __v_56: G = G::from_bool(__v_55 == G::ZERO); let __v_57: G = G::from_u64(1); if (__v_56 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None }); } let __v_58: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_51, __v_0, __v_20, __v_19, __v_58, __v_18, __v_15, __v_16, __v_17, __v_53, __v_7, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_59, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_60, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, &__args[..])?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_62: G = __loaded[0]; let __v_63: G = __loaded[1]; let __v_64: G = __loaded[2]; let __v_65: G = __loaded[3]; let __v_66: G = __loaded[4]; let __v_67: G = __loaded[5]; let __v_68: G = __loaded[6]; match __v_62.as_canonical_u64() { 0u64 => { match __v_63.as_canonical_u64() { _ => { let __v_69: G = __v_63 - __v_20; let __v_70: G = G::from_bool(__v_69 == G::ZERO); let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_66, __v_67, __v_21, __v_22, __v_2, __v_0, __v_20, __v_68, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_23, __v_75]; 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_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = __v_76 - __v_72; let __v_79: G = G::from_bool(__v_78 == G::ZERO); let __v_80: G = __v_77 - __v_73; let __v_81: G = G::from_bool(__v_80 == G::ZERO); let __v_82: G = __v_79 * __v_81; if (__v_82 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_159] = [__v_74]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } const INPUT_SIZE_160: usize = 25; const IN_160: usize = 25; const OUT_160: usize = 1; -fn aiur_fn_160(inp: [G; IN_160], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_30]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, (&__args[..]))?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { (*(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179])) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, (&__args[..]))?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { (*(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159])) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_35]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } +fn aiur_fn_160(inp: [G; IN_160], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_30]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, &__args[..])?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_35]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } const INPUT_SIZE_161: usize = 4; const IN_161: usize = 4; const OUT_161: usize = 1; -fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_5]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, (&__args[..]))?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { (*(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179])) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_11]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_5]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = __v_2 - __v_8; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_11]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_162: usize = 2; const IN_162: usize = 2; const OUT_162: usize = 1; -fn aiur_fn_162(inp: [G; IN_162], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_162] = [__v_7]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(294, (&__args[..]))?) { [G::ZERO; OUT_294] } else { let (__hash, __hit) = record.function_queries[294].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[294].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { (*(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294])) }; __ret }, _ => { aiur_fn_294::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, (&__args[..]))?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { (*(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162])) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_162] = [__v_9]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_162(inp: [G; IN_162], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_162] = [__v_7]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(294, &__args[..])?) { [G::ZERO; OUT_294] } else { let (__hash, __hit) = record.function_queries[294].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[294].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => { aiur_fn_294::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, &__args[..])?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_162] = [__v_9]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_163: usize = 2; const IN_163: usize = 2; const OUT_163: usize = 1; -fn aiur_fn_163(inp: [G; IN_163], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_8]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_10]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_163(inp: [G; IN_163], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_8]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_10]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_164: usize = 4; const IN_164: usize = 4; const OUT_164: usize = 1; -fn aiur_fn_164(inp: [G; IN_164], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_5]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, (&__args[..]))?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { (*(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162])) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __v_9: G = (__v_3 - __v_7); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_164(inp: [G; IN_164], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_5]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, &__args[..])?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_2 + __v_7; let __v_9: G = __v_3 - __v_7; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_165: usize = 13; const IN_165: usize = 13; const OUT_165: usize = 1; -fn aiur_fn_165(inp: [G; IN_165], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, (&__args[..]))?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { (*(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152])) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_13]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_6.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_165] = [__v_27]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_9, __v_11, __v_8, __v_10, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, (&__args[..]))?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { (*(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154])) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, (&__args[..]))?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { (*(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153])) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_12 - __v_32); let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, (&__args[..]))?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { (*(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166])) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_35]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } +fn aiur_fn_165(inp: [G; IN_165], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_13]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_6.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_165] = [__v_27]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_9, __v_11, __v_8, __v_10, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, &__args[..])?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __v_12 - __v_32; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_35]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } const INPUT_SIZE_166: usize = 2; const IN_166: usize = 2; const OUT_166: usize = 1; -fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_166] = [__v_0]; record.function_queries[166].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, (&__args[..]))?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { (*(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166])) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_166] = [__v_8]; record.function_queries[166].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_166] = [__v_0]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_166] = [__v_8]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_167: usize = 2; const IN_167: usize = 2; const OUT_167: usize = 1; -fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_167] = [__v_6]; record.function_queries[167].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, (&__args[..]))?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { (*(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167])) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_167] = [__v_11]; record.function_queries[167].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_167] = [__v_6]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_167] = [__v_11]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_168: usize = 6; const IN_168: usize = 6; const OUT_168: usize = 1; -fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_11: G = __r_arr[0]; let __v_12: G = G::from_bool((__v_11 == G::ZERO)); let __ret: [G; OUT_168] = [__v_12]; record.function_queries[168].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_16: G = __r_arr[0]; if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, (&__args[..]))?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { (*(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166])) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_14); let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, (&__args[..]))?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { (*(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167])) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_18, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_24: G = (__v_4 + __v_14); let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_168] = [__v_25]; record.function_queries[168].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_11: G = __r_arr[0]; let __v_12: G = G::from_bool(__v_11 == G::ZERO); let __ret: [G; OUT_168] = [__v_12]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_16: G = __r_arr[0]; if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_5 - __v_14; let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_18, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_24: G = __v_4 + __v_14; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_168] = [__v_25]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_169: usize = 32; const IN_169: usize = 32; const OUT_169: usize = 1; -fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6]; 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, (&__args[..]))?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { (*(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301])) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = (__v_33 - __v_32); let __v_35: G = G::from_bool((__v_34 == G::ZERO)); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_8]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_38 + __v_39); if (__v_37 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; 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_41: G = __r_arr[0]; let __v_42: G = (__v_41 - __v_32); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); if (__v_43 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_10]; 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_44: G = __r_arr[0]; if (__v_44 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __v_45: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_45]; }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; break '__mc_0 [__v_46]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; let __v_46: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_49]; 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 __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __v_71: G = G::from_u64(256); let __v_72: G = (__v_71 * __v_54); let __v_73: G = G::from_u64(65536); let __v_74: G = (__v_73 * __v_55); let __v_75: G = G::from_u64(16777216); let __v_76: G = (__v_75 * __v_56); let __v_77: G = G::from_u64(4294967296); let __v_78: G = (__v_77 * __v_57); let __v_79: G = G::from_u64(1099511627776); let __v_80: G = (__v_79 * __v_58); let __v_81: G = G::from_u64(281474976710656); let __v_82: G = (__v_81 * __v_59); let __v_83: G = G::from_u64(72057594037927936); let __v_84: G = (__v_83 * __v_60); let __v_85: G = (__v_82 + __v_84); let __v_86: G = (__v_80 + __v_85); let __v_87: G = (__v_78 + __v_86); let __v_88: G = (__v_76 + __v_87); let __v_89: G = (__v_74 + __v_88); let __v_90: G = (__v_72 + __v_89); let __v_91: G = (__v_53 + __v_90); let __v_92: G = (__v_71 * __v_62); let __v_93: G = (__v_73 * __v_63); let __v_94: G = (__v_75 * __v_64); let __v_95: G = (__v_77 * __v_65); let __v_96: G = (__v_79 * __v_66); let __v_97: G = (__v_81 * __v_67); let __v_98: G = (__v_83 * __v_68); let __v_99: G = (__v_97 + __v_98); let __v_100: G = (__v_96 + __v_99); let __v_101: G = (__v_95 + __v_100); let __v_102: G = (__v_94 + __v_101); let __v_103: G = (__v_93 + __v_102); let __v_104: G = (__v_92 + __v_103); let __v_105: G = (__v_61 + __v_104); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_69, __v_6, __v_7, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, (&__args[..]))?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { (*(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134])) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_107, __v_108]; 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_109: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_109, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_110: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = (__v_32 + __v_28); let __v_114: G = G::from_u64(33); let __v_115: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_114.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; if (__v_115 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_111, __v_112, __v_29, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_116: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_8, __v_116, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_117: G = __r_arr[0]; if (__v_117 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __v_118: G = G::from_u64(0); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_111, __v_112, __v_119, __v_91, __v_105, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_113, __v_106, __v_6, __v_10, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_121: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_121]; record.function_queries[169].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6]; 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __v_33 - __v_32; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_8]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __v_38 + __v_39; if (__v_37 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; 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_41: G = __r_arr[0]; let __v_42: G = __v_41 - __v_32; let __v_43: G = G::from_bool(__v_42 == G::ZERO); if (__v_43 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_10]; 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_44: G = __r_arr[0]; if (__v_44 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __v_45: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_45]; }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; break '__mc_0 [__v_46]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; let __v_46: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_49]; 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 __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __v_71: G = G::from_u64(256); let __v_72: G = __v_71 * __v_54; let __v_73: G = G::from_u64(65536); let __v_74: G = __v_73 * __v_55; let __v_75: G = G::from_u64(16777216); let __v_76: G = __v_75 * __v_56; let __v_77: G = G::from_u64(4294967296); let __v_78: G = __v_77 * __v_57; let __v_79: G = G::from_u64(1099511627776); let __v_80: G = __v_79 * __v_58; let __v_81: G = G::from_u64(281474976710656); let __v_82: G = __v_81 * __v_59; let __v_83: G = G::from_u64(72057594037927936); let __v_84: G = __v_83 * __v_60; let __v_85: G = __v_82 + __v_84; let __v_86: G = __v_80 + __v_85; let __v_87: G = __v_78 + __v_86; let __v_88: G = __v_76 + __v_87; let __v_89: G = __v_74 + __v_88; let __v_90: G = __v_72 + __v_89; let __v_91: G = __v_53 + __v_90; let __v_92: G = __v_71 * __v_62; let __v_93: G = __v_73 * __v_63; let __v_94: G = __v_75 * __v_64; let __v_95: G = __v_77 * __v_65; let __v_96: G = __v_79 * __v_66; let __v_97: G = __v_81 * __v_67; let __v_98: G = __v_83 * __v_68; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_96 + __v_99; let __v_101: G = __v_95 + __v_100; let __v_102: G = __v_94 + __v_101; let __v_103: G = __v_93 + __v_102; let __v_104: G = __v_92 + __v_103; let __v_105: G = __v_61 + __v_104; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_69, __v_6, __v_7, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_107, __v_108]; 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_109: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_109, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_110: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = __v_32 + __v_28; let __v_114: G = G::from_u64(33); let __v_115: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_114.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; if (__v_115 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_111, __v_112, __v_29, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_116: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_8, __v_116, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_117: G = __r_arr[0]; if (__v_117 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __v_118: G = G::from_u64(0); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_111, __v_112, __v_119, __v_91, __v_105, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_113, __v_106, __v_6, __v_10, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_121: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_121]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_170: usize = 2; const IN_170: usize = 2; const OUT_170: usize = 1; -fn aiur_fn_170(inp: [G; IN_170], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool((__v_0 == G::ZERO)); let __v_3: G = G::from_bool((__v_1 == G::ZERO)); let __v_4: G = (__v_2 * __v_3); let __ret: [G; OUT_170] = [__v_4]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_170(inp: [G; IN_170], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool(__v_0 == G::ZERO); let __v_3: G = G::from_bool(__v_1 == G::ZERO); let __v_4: G = __v_2 * __v_3; let __ret: [G; OUT_170] = [__v_4]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_171: usize = 9; const IN_171: usize = 9; const OUT_171: usize = 1; -fn aiur_fn_171(inp: [G; IN_171], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 3] = [__v_9, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 3] = [__v_9, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_9, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_0, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_171] = [__v_17]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_171(inp: [G; IN_171], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 3] = [__v_9, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 3] = [__v_9, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_9, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_0, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_171] = [__v_17]; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_172: usize = 33; const IN_172: usize = 33; const OUT_172: usize = 1; -fn aiur_fn_172(inp: [G; IN_172], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_36]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_172(inp: [G; IN_172], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_36]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_173: usize = 2; const IN_173: usize = 2; const OUT_173: usize = 1; -fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_173] = [__v_1]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __v_23: G = __loaded[18]; let __v_24: G = __loaded[19]; let __v_25: G = __loaded[20]; let __v_26: G = __loaded[21]; let __v_27: G = __loaded[22]; let __v_28: G = __loaded[23]; let __v_29: G = __loaded[24]; let __v_30: G = __loaded[25]; let __v_31: G = __loaded[26]; let __v_32: G = __loaded[27]; let __v_33: G = __loaded[28]; let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_173] = [__v_41]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_173] = [__v_1]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __v_23: G = __loaded[18]; let __v_24: G = __loaded[19]; let __v_25: G = __loaded[20]; let __v_26: G = __loaded[21]; let __v_27: G = __loaded[22]; let __v_28: G = __loaded[23]; let __v_29: G = __loaded[24]; let __v_30: G = __loaded[25]; let __v_31: G = __loaded[26]; let __v_32: G = __loaded[27]; let __v_33: G = __loaded[28]; let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_173] = [__v_41]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_174: usize = 2; const IN_174: usize = 2; const OUT_174: usize = 1; -fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_174] = [__v_1]; record.function_queries[174].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_174] = [__v_7]; record.function_queries[174].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_174] = [__v_1]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_174] = [__v_7]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_175: usize = 2; const IN_175: usize = 2; const OUT_175: usize = 10; -fn aiur_fn_175(inp: [G; IN_175], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(103); let __v_6: G = G::from_u64(230); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(106); let __v_9: G = G::from_u64(133); let __v_10: G = G::from_u64(174); let __v_11: G = G::from_u64(187); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(243); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(165); let __v_20: G = G::from_u64(127); let __v_21: G = G::from_u64(82); let __v_22: G = G::from_u64(14); let __v_23: G = G::from_u64(81); let __v_24: G = G::from_u64(140); let __v_25: G = G::from_u64(104); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(31); let __v_32: G = G::from_u64(25); let __v_33: G = G::from_u64(205); let __v_34: G = G::from_u64(224); let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 8] = [__v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 34] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = __r_arr[2]; let __v_46: G = __r_arr[3]; let __v_47: G = __r_arr[4]; let __v_48: G = __r_arr[5]; let __v_49: G = __r_arr[6]; let __v_50: G = __r_arr[7]; let __v_51: G = __r_arr[8]; let __v_52: G = __r_arr[9]; let __v_53: G = __r_arr[10]; let __v_54: G = __r_arr[11]; let __v_55: G = __r_arr[12]; let __v_56: G = __r_arr[13]; let __v_57: G = __r_arr[14]; let __v_58: G = __r_arr[15]; let __v_59: G = __r_arr[16]; let __v_60: G = __r_arr[17]; let __v_61: G = __r_arr[18]; let __v_62: G = __r_arr[19]; let __v_63: G = __r_arr[20]; let __v_64: G = __r_arr[21]; let __v_65: G = __r_arr[22]; let __v_66: G = __r_arr[23]; let __v_67: G = __r_arr[24]; let __v_68: G = __r_arr[25]; let __v_69: G = __r_arr[26]; let __v_70: G = __r_arr[27]; let __v_71: G = __r_arr[28]; let __v_72: G = __r_arr[29]; let __v_73: G = __r_arr[30]; let __v_74: G = __r_arr[31]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_71, __v_72, __v_73, __v_74, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_67, __v_68, __v_69, __v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_63, __v_64, __v_65, __v_66, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_59, __v_60, __v_61, __v_62, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_51, __v_52, __v_53, __v_54, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_47, __v_48, __v_49, __v_50, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_43, __v_44, __v_45, __v_46, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, (&__args[..]))?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { (*(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129])) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_83.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; match __v_84.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; match __v_87.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_89.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_90: G = __loaded[0]; let __v_91: G = __loaded[1]; let __v_92: G = __loaded[2]; match __v_90.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; match __v_93.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_95.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_96: G = __loaded[0]; let __v_97: G = __loaded[1]; let __v_98: G = __loaded[2]; match __v_96.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_99: G = __loaded[0]; let __v_100: G = __loaded[1]; let __v_101: G = __loaded[2]; match __v_99.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_101.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_102: G = __loaded[0]; let __v_103: G = __loaded[1]; let __v_104: G = __loaded[2]; match __v_102.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_105: G = __loaded[0]; let __v_106: G = __loaded[1]; let __v_107: G = __loaded[2]; match __v_105.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_175] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_105.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_99.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_96.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_93.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_90.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_87.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_84.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_175] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_175(inp: [G; IN_175], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(103); let __v_6: G = G::from_u64(230); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(106); let __v_9: G = G::from_u64(133); let __v_10: G = G::from_u64(174); let __v_11: G = G::from_u64(187); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(243); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(165); let __v_20: G = G::from_u64(127); let __v_21: G = G::from_u64(82); let __v_22: G = G::from_u64(14); let __v_23: G = G::from_u64(81); let __v_24: G = G::from_u64(140); let __v_25: G = G::from_u64(104); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(31); let __v_32: G = G::from_u64(25); let __v_33: G = G::from_u64(205); let __v_34: G = G::from_u64(224); let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 8] = [__v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 34] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = __r_arr[2]; let __v_46: G = __r_arr[3]; let __v_47: G = __r_arr[4]; let __v_48: G = __r_arr[5]; let __v_49: G = __r_arr[6]; let __v_50: G = __r_arr[7]; let __v_51: G = __r_arr[8]; let __v_52: G = __r_arr[9]; let __v_53: G = __r_arr[10]; let __v_54: G = __r_arr[11]; let __v_55: G = __r_arr[12]; let __v_56: G = __r_arr[13]; let __v_57: G = __r_arr[14]; let __v_58: G = __r_arr[15]; let __v_59: G = __r_arr[16]; let __v_60: G = __r_arr[17]; let __v_61: G = __r_arr[18]; let __v_62: G = __r_arr[19]; let __v_63: G = __r_arr[20]; let __v_64: G = __r_arr[21]; let __v_65: G = __r_arr[22]; let __v_66: G = __r_arr[23]; let __v_67: G = __r_arr[24]; let __v_68: G = __r_arr[25]; let __v_69: G = __r_arr[26]; let __v_70: G = __r_arr[27]; let __v_71: G = __r_arr[28]; let __v_72: G = __r_arr[29]; let __v_73: G = __r_arr[30]; let __v_74: G = __r_arr[31]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_71, __v_72, __v_73, __v_74, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_67, __v_68, __v_69, __v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_63, __v_64, __v_65, __v_66, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_59, __v_60, __v_61, __v_62, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_51, __v_52, __v_53, __v_54, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_47, __v_48, __v_49, __v_50, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_43, __v_44, __v_45, __v_46, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_83.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; match __v_84.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; match __v_87.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_89.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_90: G = __loaded[0]; let __v_91: G = __loaded[1]; let __v_92: G = __loaded[2]; match __v_90.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; match __v_93.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_95.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_96: G = __loaded[0]; let __v_97: G = __loaded[1]; let __v_98: G = __loaded[2]; match __v_96.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_99: G = __loaded[0]; let __v_100: G = __loaded[1]; let __v_101: G = __loaded[2]; match __v_99.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_101.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_102: G = __loaded[0]; let __v_103: G = __loaded[1]; let __v_104: G = __loaded[2]; match __v_102.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_105: G = __loaded[0]; let __v_106: G = __loaded[1]; let __v_107: G = __loaded[2]; match __v_105.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_175] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_105.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_99.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_96.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_93.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_90.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_87.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_84.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_175] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_176: usize = 2; const IN_176: usize = 2; const OUT_176: usize = 10; -fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1020); let __v_13: G = (__v_9 - __v_12); let __v_14: G = (__v_8 + __v_13); let __v_15: G = (__v_7 + __v_14); let __v_16: G = (__v_6 + __v_15); let __v_17: G = G::from_bool((__v_16 == G::ZERO)); let __v_18: G = (__v_4 + __v_5); let __v_19: G = (__v_3 + __v_18); let __v_20: G = (__v_2 + __v_19); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); let __v_22: G = G::from_u64(1); let __v_23: G = (__v_22 - __v_21); let __v_24: G = (__v_17 * __v_23); let __v_25: G = (__v_22 - __v_24); match __v_25.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_176] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[176].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = __r_arr[9]; let __ret: [G; OUT_176] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[176].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, &__args[..])?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1020); let __v_13: G = __v_9 - __v_12; let __v_14: G = __v_8 + __v_13; let __v_15: G = __v_7 + __v_14; let __v_16: G = __v_6 + __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = __v_4 + __v_5; let __v_19: G = __v_3 + __v_18; let __v_20: G = __v_2 + __v_19; let __v_21: G = G::from_bool(__v_20 == G::ZERO); let __v_22: G = G::from_u64(1); let __v_23: G = __v_22 - __v_21; let __v_24: G = __v_17 * __v_23; let __v_25: G = __v_22 - __v_24; match __v_25.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_176] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = __r_arr[9]; let __ret: [G; OUT_176] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_177: usize = 2; const IN_177: usize = 2; const OUT_177: usize = 18; -fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_177] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[177].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_177] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_178: usize = 2; const IN_178: usize = 2; const OUT_178: usize = 1; -fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_178] = [__v_3]; record.function_queries[178].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_178] = [__v_9]; record.function_queries[178].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_178] = [__v_3]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_178] = [__v_9]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_179: usize = 3; const IN_179: usize = 3; const OUT_179: usize = 3; -fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_3)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_3, record) }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; let __v_16: G = __b1_out[3]; let __v_17: G = __b1_out[4]; let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_4)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_4, record) }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; let __v_24: G = __b1_out[3]; let __v_25: G = __b1_out[4]; let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_5)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_5, record) }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; let __v_32: G = __b1_out[3]; let __v_33: G = __b1_out[4]; let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_6)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_6, record) }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; let __v_40: G = __b1_out[3]; let __v_41: G = __b1_out[4]; let __v_42: G = __b1_out[5]; let __v_43: G = __b1_out[6]; let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_179] = [__v_51, __v_11, __v_12]; record.function_queries[179].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, &__args[..])?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_3, record) }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; let __v_16: G = __b1_out[3]; let __v_17: G = __b1_out[4]; let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_4, record) }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; let __v_24: G = __b1_out[3]; let __v_25: G = __b1_out[4]; let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_5, record) }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; let __v_32: G = __b1_out[3]; let __v_33: G = __b1_out[4]; let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_6, record) }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; let __v_40: G = __b1_out[3]; let __v_41: G = __b1_out[4]; let __v_42: G = __b1_out[5]; let __v_43: G = __b1_out[6]; let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_179] = [__v_51, __v_11, __v_12]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_180: usize = 9; const IN_180: usize = 9; const OUT_180: usize = 1; -fn aiur_fn_180(inp: [G; IN_180], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __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_12: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_12]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_180(inp: [G; IN_180], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __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_12: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_12]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_181: usize = 2; const IN_181: usize = 2; const OUT_181: usize = 1; -fn aiur_fn_181(inp: [G; IN_181], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __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_5: G = __r_arr[0]; let __ret: [G; OUT_181] = [__v_5]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_181(inp: [G; IN_181], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __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_5: G = __r_arr[0]; let __ret: [G; OUT_181] = [__v_5]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_182: usize = 1; const IN_182: usize = 1; const OUT_182: usize = 1; -fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(108); let __v_5: G = G::from_u64(116); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(45); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(107); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(118); let __v_14: G = G::from_u64(48); let __v_15: G = { let __values: [G; 3] = [__v_1, __v_14, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_1, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_1, __v_12, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 3] = [__v_1, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_10, __v_18]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_20: G = { let __values: [G; 3] = [__v_1, __v_9, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_21: G = { let __values: [G; 3] = [__v_1, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_1, __v_8, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_23: G = { let __values: [G; 3] = [__v_1, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_24: G = { let __values: [G; 3] = [__v_1, __v_6, __v_23]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_25: G = { let __values: [G; 3] = [__v_1, __v_5, __v_24]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_26: G = { let __values: [G; 3] = [__v_1, __v_4, __v_25]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_1, __v_3, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_1, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_182] = [__v_28]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(108); let __v_5: G = G::from_u64(116); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(45); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(107); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(118); let __v_14: G = G::from_u64(48); let __v_15: G = { let __values: [G; 3] = [__v_1, __v_14, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_1, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_1, __v_12, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 3] = [__v_1, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_10, __v_18]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_20: G = { let __values: [G; 3] = [__v_1, __v_9, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_21: G = { let __values: [G; 3] = [__v_1, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_1, __v_8, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_23: G = { let __values: [G; 3] = [__v_1, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_24: G = { let __values: [G; 3] = [__v_1, __v_6, __v_23]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_25: G = { let __values: [G; 3] = [__v_1, __v_5, __v_24]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_26: G = { let __values: [G; 3] = [__v_1, __v_4, __v_25]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_1, __v_3, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_1, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_182] = [__v_28]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_183: usize = 2; const IN_183: usize = 2; const OUT_183: usize = 1; -fn aiur_fn_183(inp: [G; IN_183], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_13]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_183(inp: [G; IN_183], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_13]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_184: usize = 2; const IN_184: usize = 2; const OUT_184: usize = 1; -fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_184] = [__v_3]; record.function_queries[184].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_184] = [__v_1]; record.function_queries[184].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_184] = [__v_3]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_184] = [__v_1]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_185: usize = 3; const IN_185: usize = 3; const OUT_185: usize = 2; -fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_185] = [__v_0, __v_1]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = (__v_0 * __v_0); let __v_4: G = G::from_u64(7); let __v_5: G = (__v_1 * __v_1); let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_3 + __v_6); let __v_8: G = (__v_0 * __v_1); let __v_9: G = (__v_1 * __v_0); let __v_10: G = (__v_8 + __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 - __v_11); let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_185] = [__v_13, __v_14]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_185] = [__v_0, __v_1]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = __v_0 * __v_0; let __v_4: G = G::from_u64(7); let __v_5: G = __v_1 * __v_1; let __v_6: G = __v_4 * __v_5; let __v_7: G = __v_3 + __v_6; let __v_8: G = __v_0 * __v_1; let __v_9: G = __v_1 * __v_0; let __v_10: G = __v_8 + __v_9; let __v_11: G = G::from_u64(1); let __v_12: G = __v_2 - __v_11; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_185] = [__v_13, __v_14]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_186: usize = 1; const IN_186: usize = 1; const OUT_186: usize = 1; -fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_186] = [__v_1]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_186] = [__v_1]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 + __v_1); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); let __ret: [G; OUT_186] = [__v_4]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_186] = [__v_1]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_186] = [__v_1]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = __v_0 + __v_1; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __v_3 * __v_3; let __ret: [G; OUT_186] = [__v_4]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_187: usize = 3; const IN_187: usize = 3; const OUT_187: usize = 2; -fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); let __ret: [G; OUT_187] = [__v_7, __v_8]; record.function_queries[187].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = __v_3 - __v_5; let __v_8: G = __v_4 - __v_6; let __ret: [G; OUT_187] = [__v_7, __v_8]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_188: usize = 1; const IN_188: usize = 1; const OUT_188: usize = 1; -fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_188] = [__v_1]; record.function_queries[188].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = (__v_0 - __v_2); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, (&__args[..]))?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { (*(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188])) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_188] = [__v_5]; record.function_queries[188].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_188] = [__v_1]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = __v_0 - __v_2; let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, &__args[..])?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_1 * __v_4; let __ret: [G; OUT_188] = [__v_5]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_189: usize = 3; const IN_189: usize = 3; const OUT_189: usize = 8; -fn aiur_fn_189(inp: [G; IN_189], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = aiur::execute::g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_11 - __v_5); let __v_13: G = (__v_9 * __v_12); if (__v_13 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_14: G = (__v_10 * __v_12); if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_0 - __v_5); let __v_16: G = (__v_1 - __v_6); let __v_17: G = (__v_15 * __v_15); let __v_18: G = G::from_u64(7); let __v_19: G = (__v_16 * __v_16); let __v_20: G = (__v_18 * __v_19); let __v_21: G = (__v_17 - __v_20); let __v_22: G = aiur::execute::g_inverse_value(__v_21); let __v_23: G = (__v_21 * __v_22); let __v_24: G = (__v_23 - __v_5); let __v_25: G = (__v_21 * __v_24); if (__v_25 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_26: G = (__v_22 * __v_24); if (__v_26 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_27: G = (__v_15 * __v_22); let __v_28: G = (__v_6 - __v_16); let __v_29: G = (__v_28 * __v_22); let __v_30: G = (__v_7 * __v_27); let __v_31: G = (__v_8 * __v_29); let __v_32: G = (__v_18 * __v_31); let __v_33: G = (__v_30 + __v_32); let __v_34: G = (__v_7 * __v_29); let __v_35: G = (__v_8 * __v_27); let __v_36: G = (__v_34 + __v_35); let __v_37: G = (__v_0 - __v_10); let __v_38: G = (__v_37 * __v_37); let __v_39: G = (__v_38 - __v_20); let __v_40: G = aiur::execute::g_inverse_value(__v_39); let __v_41: G = (__v_39 * __v_40); let __v_42: G = (__v_41 - __v_5); let __v_43: G = (__v_39 * __v_42); if (__v_43 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_44: G = (__v_40 * __v_42); if (__v_44 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_45: G = (__v_37 * __v_40); let __v_46: G = (__v_28 * __v_40); let __v_47: G = (__v_7 * __v_45); let __v_48: G = (__v_8 * __v_46); let __v_49: G = (__v_18 * __v_48); let __v_50: G = (__v_47 + __v_49); let __v_51: G = (__v_7 * __v_46); let __v_52: G = (__v_8 * __v_45); let __v_53: G = (__v_51 + __v_52); let __v_54: G = (__v_7 * __v_7); let __v_55: G = (__v_8 * __v_8); let __v_56: G = (__v_18 * __v_55); let __v_57: G = (__v_54 - __v_56); let __v_58: G = aiur::execute::g_inverse_value(__v_57); let __v_59: G = (__v_57 * __v_58); let __v_60: G = (__v_59 - __v_5); let __v_61: G = (__v_57 * __v_60); if (__v_61 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_62: G = (__v_58 * __v_60); if (__v_62 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_63: G = (__v_7 * __v_58); let __v_64: G = (__v_6 - __v_8); let __v_65: G = (__v_64 * __v_58); let __ret: [G; OUT_189] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_189(inp: [G; IN_189], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = __v_3 - __v_5; let __v_8: G = __v_4 - __v_6; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = aiur::execute::g_inverse_value(__v_9); let __v_11: G = __v_9 * __v_10; let __v_12: G = __v_11 - __v_5; let __v_13: G = __v_9 * __v_12; if (__v_13 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_14: G = __v_10 * __v_12; if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_15: G = __v_0 - __v_5; let __v_16: G = __v_1 - __v_6; let __v_17: G = __v_15 * __v_15; let __v_18: G = G::from_u64(7); let __v_19: G = __v_16 * __v_16; let __v_20: G = __v_18 * __v_19; let __v_21: G = __v_17 - __v_20; let __v_22: G = aiur::execute::g_inverse_value(__v_21); let __v_23: G = __v_21 * __v_22; let __v_24: G = __v_23 - __v_5; let __v_25: G = __v_21 * __v_24; if (__v_25 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_26: G = __v_22 * __v_24; if (__v_26 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_27: G = __v_15 * __v_22; let __v_28: G = __v_6 - __v_16; let __v_29: G = __v_28 * __v_22; let __v_30: G = __v_7 * __v_27; let __v_31: G = __v_8 * __v_29; let __v_32: G = __v_18 * __v_31; let __v_33: G = __v_30 + __v_32; let __v_34: G = __v_7 * __v_29; let __v_35: G = __v_8 * __v_27; let __v_36: G = __v_34 + __v_35; let __v_37: G = __v_0 - __v_10; let __v_38: G = __v_37 * __v_37; let __v_39: G = __v_38 - __v_20; let __v_40: G = aiur::execute::g_inverse_value(__v_39); let __v_41: G = __v_39 * __v_40; let __v_42: G = __v_41 - __v_5; let __v_43: G = __v_39 * __v_42; if (__v_43 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_44: G = __v_40 * __v_42; if (__v_44 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_45: G = __v_37 * __v_40; let __v_46: G = __v_28 * __v_40; let __v_47: G = __v_7 * __v_45; let __v_48: G = __v_8 * __v_46; let __v_49: G = __v_18 * __v_48; let __v_50: G = __v_47 + __v_49; let __v_51: G = __v_7 * __v_46; let __v_52: G = __v_8 * __v_45; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_7 * __v_7; let __v_55: G = __v_8 * __v_8; let __v_56: G = __v_18 * __v_55; let __v_57: G = __v_54 - __v_56; let __v_58: G = aiur::execute::g_inverse_value(__v_57); let __v_59: G = __v_57 * __v_58; let __v_60: G = __v_59 - __v_5; let __v_61: G = __v_57 * __v_60; if (__v_61 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_62: G = __v_58 * __v_60; if (__v_62 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_63: G = __v_7 * __v_58; let __v_64: G = __v_6 - __v_8; let __v_65: G = __v_64 * __v_58; let __ret: [G; OUT_189] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_190: usize = 6; const IN_190: usize = 6; const OUT_190: usize = 2; -fn aiur_fn_190(inp: [G; IN_190], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = (__v_0 * __v_2); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_1 * __v_3); let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_0 * __v_3); let __v_12: G = (__v_1 * __v_2); let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_10 + __v_4); let __v_15: G = (__v_13 + __v_5); let __ret: [G; OUT_190] = [__v_14, __v_15]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_190(inp: [G; IN_190], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = __v_0 * __v_2; let __v_7: G = G::from_u64(7); let __v_8: G = __v_1 * __v_3; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_0 * __v_3; let __v_12: G = __v_1 * __v_2; let __v_13: G = __v_11 + __v_12; let __v_14: G = __v_10 + __v_4; let __v_15: G = __v_13 + __v_5; let __ret: [G; OUT_190] = [__v_14, __v_15]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_191: usize = 4; const IN_191: usize = 4; const OUT_191: usize = 2; -fn aiur_fn_191(inp: [G; IN_191], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 * __v_4); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_3 * __v_5); let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_2 * __v_5); let __v_12: G = (__v_3 * __v_4); let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_0 + __v_10); let __v_15: G = (__v_1 + __v_13); let __ret: [G; OUT_191] = [__v_14, __v_15]; record.function_queries[191].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_191(inp: [G; IN_191], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = __v_2 * __v_4; let __v_7: G = G::from_u64(7); let __v_8: G = __v_3 * __v_5; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_2 * __v_5; let __v_12: G = __v_3 * __v_4; let __v_13: G = __v_11 + __v_12; let __v_14: G = __v_0 + __v_10; let __v_15: G = __v_1 + __v_13; let __ret: [G; OUT_191] = [__v_14, __v_15]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_192: usize = 1; const IN_192: usize = 1; const OUT_192: usize = 1; -fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_192] = [__v_6]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_192] = [__v_13]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_192] = [__v_6]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_192] = [__v_13]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_193: usize = 15; const IN_193: usize = 15; const OUT_193: usize = 2; -fn aiur_fn_193(inp: [G; IN_193], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(303, (&__args[..]))?) { [G::ZERO; OUT_303] } else { let (__hash, __hit) = record.function_queries[303].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[303].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { (*(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303])) }; __ret }, _ => { aiur_fn_303::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_16, __v_19]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = (__v_16 + __v_17); let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_2, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_16]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_19, __v_20]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_193] = [__v_9, __v_10]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_193] = [__v_11, __v_12]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_193] = [__v_13, __v_14]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 + __v_21); let __v_24: G = (__v_20 + __v_22); let __ret: [G; OUT_193] = [__v_23, __v_24]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 - __v_21); let __v_24: G = (__v_20 - __v_22); let __ret: [G; OUT_193] = [__v_23, __v_24]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 * __v_21); let __v_24: G = G::from_u64(7); let __v_25: G = (__v_20 * __v_22); let __v_26: G = (__v_24 * __v_25); let __v_27: G = (__v_23 + __v_26); let __v_28: G = (__v_19 * __v_22); let __v_29: G = (__v_20 * __v_21); let __v_30: G = (__v_28 + __v_29); let __ret: [G; OUT_193] = [__v_27, __v_30]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); let __v_22: G = (__v_21 - __v_19); let __v_23: G = (__v_21 - __v_20); let __ret: [G; OUT_193] = [__v_22, __v_23]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } +fn aiur_fn_193(inp: [G; IN_193], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(303, &__args[..])?) { [G::ZERO; OUT_303] } else { let (__hash, __hit) = record.function_queries[303].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[303].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => { aiur_fn_303::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_16, __v_19]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = __v_16 + __v_17; let __v_20: G = __v_16 + __v_19; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_2, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_16]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_19, __v_20]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_193] = [__v_9, __v_10]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_193] = [__v_11, __v_12]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_193] = [__v_13, __v_14]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_19 + __v_21; let __v_24: G = __v_20 + __v_22; let __ret: [G; OUT_193] = [__v_23, __v_24]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_19 - __v_21; let __v_24: G = __v_20 - __v_22; let __ret: [G; OUT_193] = [__v_23, __v_24]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_19 * __v_21; let __v_24: G = G::from_u64(7); let __v_25: G = __v_20 * __v_22; let __v_26: G = __v_24 * __v_25; let __v_27: G = __v_23 + __v_26; let __v_28: G = __v_19 * __v_22; let __v_29: G = __v_20 * __v_21; let __v_30: G = __v_28 + __v_29; let __ret: [G; OUT_193] = [__v_27, __v_30]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); let __v_22: G = __v_21 - __v_19; let __v_23: G = __v_21 - __v_20; let __ret: [G; OUT_193] = [__v_22, __v_23]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } const INPUT_SIZE_194: usize = 19; const IN_194: usize = 19; const OUT_194: usize = 2; -fn aiur_fn_194(inp: [G; IN_194], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_26, __v_27]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } +fn aiur_fn_194(inp: [G; IN_194], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_26, __v_27]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } const INPUT_SIZE_195: usize = 8; const IN_195: usize = 8; const OUT_195: usize = 4; -fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = (__v_0 * __v_4); let __v_9: G = G::from_u64(7); let __v_10: G = (__v_1 * __v_5); let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_8 + __v_11); let __v_13: G = (__v_0 * __v_5); let __v_14: G = (__v_1 * __v_4); let __v_15: G = (__v_13 + __v_14); let __v_16: G = G::from_u64(0); let __v_17: G = (__v_2 * __v_6); let __v_18: G = (__v_3 * __v_7); let __v_19: G = (__v_9 * __v_18); let __v_20: G = (__v_17 + __v_19); let __v_21: G = (__v_2 * __v_7); let __v_22: G = (__v_3 * __v_6); let __v_23: G = (__v_21 + __v_22); let __v_24: G = (__v_9 * __v_20); let __v_25: G = (__v_16 * __v_23); let __v_26: G = (__v_9 * __v_25); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_9 * __v_23); let __v_29: G = (__v_16 * __v_20); let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_12 + __v_27); let __v_32: G = (__v_15 + __v_30); let __v_33: G = (__v_0 * __v_6); let __v_34: G = (__v_1 * __v_7); let __v_35: G = (__v_9 * __v_34); let __v_36: G = (__v_33 + __v_35); let __v_37: G = (__v_0 * __v_7); let __v_38: G = (__v_1 * __v_6); let __v_39: G = (__v_37 + __v_38); let __v_40: G = (__v_2 * __v_4); let __v_41: G = (__v_3 * __v_5); let __v_42: G = (__v_9 * __v_41); let __v_43: G = (__v_40 + __v_42); let __v_44: G = (__v_2 * __v_5); let __v_45: G = (__v_3 * __v_4); let __v_46: G = (__v_44 + __v_45); let __v_47: G = (__v_36 + __v_43); let __v_48: G = (__v_39 + __v_46); let __ret: [G; OUT_195] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = __v_0 * __v_4; let __v_9: G = G::from_u64(7); let __v_10: G = __v_1 * __v_5; let __v_11: G = __v_9 * __v_10; let __v_12: G = __v_8 + __v_11; let __v_13: G = __v_0 * __v_5; let __v_14: G = __v_1 * __v_4; let __v_15: G = __v_13 + __v_14; let __v_16: G = G::from_u64(0); let __v_17: G = __v_2 * __v_6; let __v_18: G = __v_3 * __v_7; let __v_19: G = __v_9 * __v_18; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_2 * __v_7; let __v_22: G = __v_3 * __v_6; let __v_23: G = __v_21 + __v_22; let __v_24: G = __v_9 * __v_20; let __v_25: G = __v_16 * __v_23; let __v_26: G = __v_9 * __v_25; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_9 * __v_23; let __v_29: G = __v_16 * __v_20; let __v_30: G = __v_28 + __v_29; let __v_31: G = __v_12 + __v_27; let __v_32: G = __v_15 + __v_30; let __v_33: G = __v_0 * __v_6; let __v_34: G = __v_1 * __v_7; let __v_35: G = __v_9 * __v_34; let __v_36: G = __v_33 + __v_35; let __v_37: G = __v_0 * __v_7; let __v_38: G = __v_1 * __v_6; let __v_39: G = __v_37 + __v_38; let __v_40: G = __v_2 * __v_4; let __v_41: G = __v_3 * __v_5; let __v_42: G = __v_9 * __v_41; let __v_43: G = __v_40 + __v_42; let __v_44: G = __v_2 * __v_5; let __v_45: G = __v_3 * __v_4; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_36 + __v_43; let __v_48: G = __v_39 + __v_46; let __ret: [G; OUT_195] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_196: usize = 19; const IN_196: usize = 19; const OUT_196: usize = 4; -fn aiur_fn_196(inp: [G; IN_196], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_196] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(196, (&__args[..]))?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { (*(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196])) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, (&__args[..]))?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { (*(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195])) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = (__v_26 + __v_30); let __v_33: G = (__v_27 + __v_31); let __ret: [G; OUT_196] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } +fn aiur_fn_196(inp: [G; IN_196], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_196] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __v_26 + __v_30; let __v_33: G = __v_27 + __v_31; let __ret: [G; OUT_196] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } const INPUT_SIZE_197: usize = 44; const IN_197: usize = 44; const OUT_197: usize = 2; -fn aiur_fn_197(inp: [G; IN_197], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_197] = [__v_0, __v_1]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(196, (&__args[..]))?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { (*(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196])) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = __r_arr[3]; let __v_52: G = (__v_48 + __v_22); let __v_53: G = (__v_49 + __v_23); let __v_54: G = (__v_50 + __v_24); let __v_55: G = (__v_51 + __v_25); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, (&__args[..]))?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { (*(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195])) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = (__v_56 * __v_10); let __v_63: G = G::from_u64(7); let __v_64: G = (__v_57 * __v_11); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 + __v_65); let __v_67: G = (__v_56 * __v_11); let __v_68: G = (__v_57 * __v_10); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_58 + __v_66); let __v_71: G = (__v_59 + __v_69); let __v_72: G = (__v_56 * __v_12); let __v_73: G = (__v_57 * __v_13); let __v_74: G = (__v_63 * __v_73); let __v_75: G = (__v_72 + __v_74); let __v_76: G = (__v_56 * __v_13); let __v_77: G = (__v_57 * __v_12); let __v_78: G = (__v_76 + __v_77); let __v_79: G = (__v_60 + __v_75); let __v_80: G = (__v_61 + __v_78); let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, (&__args[..]))?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { (*(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195])) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = G::from_u64(1); let __v_86: G = (__v_85 - __v_6); let __v_87: G = (__v_5 + __v_86); match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = (__v_7 + __v_7); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_88]; 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_89: G = __r_arr[0]; let __v_90: G = __r_arr[1]; let __v_91: G = G::from_u64(1); let __v_92: G = (__v_7 + __v_91); let __v_93: G = (__v_7 + __v_92); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_93]; 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_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_36, __v_96]; 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_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = (__v_97 + __v_18); let __v_100: G = (__v_98 + __v_19); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_36, __v_91]; 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_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = (__v_101 + __v_20); let __v_104: G = (__v_102 + __v_21); let __v_105: G = (__v_99 - __v_89); let __v_106: G = (__v_100 - __v_90); let __v_107: G = (__v_103 - __v_94); let __v_108: G = (__v_104 - __v_95); let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, (&__args[..]))?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { (*(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195])) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; let __v_111: G = __r_arr[2]; let __v_112: G = __r_arr[3]; let __v_113: G = (__v_109 - __v_70); let __v_114: G = (__v_110 - __v_71); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = (__v_111 - __v_79); let __v_118: G = (__v_112 - __v_80); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_119, __v_120]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_88: G = G::from_u64(1); let __v_89: G = (__v_8 - __v_88); match __v_89.as_canonical_u64() { 0u64 => { let __v_90: G = (__v_7 + __v_7); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_90]; 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_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = G::from_u64(1); let __v_94: G = (__v_7 + __v_93); let __v_95: G = (__v_7 + __v_94); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_95]; 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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = G::from_u64(2); let __v_99: G = (__v_7 + __v_98); let __v_100: G = (__v_7 + __v_99); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_100]; 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_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = G::from_u64(3); let __v_104: G = (__v_7 + __v_103); let __v_105: G = (__v_7 + __v_104); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_105]; 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_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = (__v_101 - __v_91); let __v_109: G = (__v_102 - __v_92); let __v_110: G = (__v_106 - __v_96); let __v_111: G = (__v_107 - __v_97); let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; 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_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = __r_arr[2]; let __v_115: G = __r_arr[3]; let __v_116: G = (__v_112 - __v_70); let __v_117: G = (__v_113 - __v_71); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = (__v_114 - __v_79); let __v_121: G = (__v_115 - __v_80); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; 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_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = (__v_5 + __v_93); let __v_125: G = G::from_u64(0); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_122, __v_123, __v_2, __v_3, __v_47, __v_124, __v_6, __v_94, __v_9, __v_9, __v_93, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_126: G = __r_arr[0]; let __v_127: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_126, __v_127]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_90: G = G::from_u64(1); let __v_91: G = (__v_5 + __v_90); let __v_92: G = (__v_8 - __v_90); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_91, __v_6, __v_7, __v_92, __v_9, __v_81, __v_82, __v_83, __v_84, __v_70, __v_71, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_93, __v_94]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } +fn aiur_fn_197(inp: [G; IN_197], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_197] = [__v_0, __v_1]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = __r_arr[3]; let __v_52: G = __v_48 + __v_22; let __v_53: G = __v_49 + __v_23; let __v_54: G = __v_50 + __v_24; let __v_55: G = __v_51 + __v_25; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __v_56 * __v_10; let __v_63: G = G::from_u64(7); let __v_64: G = __v_57 * __v_11; let __v_65: G = __v_63 * __v_64; let __v_66: G = __v_62 + __v_65; let __v_67: G = __v_56 * __v_11; let __v_68: G = __v_57 * __v_10; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_58 + __v_66; let __v_71: G = __v_59 + __v_69; let __v_72: G = __v_56 * __v_12; let __v_73: G = __v_57 * __v_13; let __v_74: G = __v_63 * __v_73; let __v_75: G = __v_72 + __v_74; let __v_76: G = __v_56 * __v_13; let __v_77: G = __v_57 * __v_12; let __v_78: G = __v_76 + __v_77; let __v_79: G = __v_60 + __v_75; let __v_80: G = __v_61 + __v_78; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = G::from_u64(1); let __v_86: G = __v_85 - __v_6; let __v_87: G = __v_5 + __v_86; match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = __v_7 + __v_7; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_88]; 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_89: G = __r_arr[0]; let __v_90: G = __r_arr[1]; let __v_91: G = G::from_u64(1); let __v_92: G = __v_7 + __v_91; let __v_93: G = __v_7 + __v_92; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_93]; 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_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_36, __v_96]; 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_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = __v_97 + __v_18; let __v_100: G = __v_98 + __v_19; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_36, __v_91]; 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_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = __v_101 + __v_20; let __v_104: G = __v_102 + __v_21; let __v_105: G = __v_99 - __v_89; let __v_106: G = __v_100 - __v_90; let __v_107: G = __v_103 - __v_94; let __v_108: G = __v_104 - __v_95; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; let __v_111: G = __r_arr[2]; let __v_112: G = __r_arr[3]; let __v_113: G = __v_109 - __v_70; let __v_114: G = __v_110 - __v_71; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = __v_111 - __v_79; let __v_118: G = __v_112 - __v_80; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_119, __v_120]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_88: G = G::from_u64(1); let __v_89: G = __v_8 - __v_88; match __v_89.as_canonical_u64() { 0u64 => { let __v_90: G = __v_7 + __v_7; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_90]; 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_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = G::from_u64(1); let __v_94: G = __v_7 + __v_93; let __v_95: G = __v_7 + __v_94; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_95]; 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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = G::from_u64(2); let __v_99: G = __v_7 + __v_98; let __v_100: G = __v_7 + __v_99; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_100]; 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_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = G::from_u64(3); let __v_104: G = __v_7 + __v_103; let __v_105: G = __v_7 + __v_104; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_35, __v_105]; 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_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __v_101 - __v_91; let __v_109: G = __v_102 - __v_92; let __v_110: G = __v_106 - __v_96; let __v_111: G = __v_107 - __v_97; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; 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_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = __r_arr[2]; let __v_115: G = __r_arr[3]; let __v_116: G = __v_112 - __v_70; let __v_117: G = __v_113 - __v_71; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = __v_114 - __v_79; let __v_121: G = __v_115 - __v_80; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; 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_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __v_5 + __v_93; let __v_125: G = G::from_u64(0); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_122, __v_123, __v_2, __v_3, __v_47, __v_124, __v_6, __v_94, __v_9, __v_9, __v_93, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_126: G = __r_arr[0]; let __v_127: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_126, __v_127]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_90: G = G::from_u64(1); let __v_91: G = __v_5 + __v_90; let __v_92: G = __v_8 - __v_90; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_91, __v_6, __v_7, __v_92, __v_9, __v_81, __v_82, __v_83, __v_84, __v_70, __v_71, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_93, __v_94]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } const INPUT_SIZE_198: usize = 28; const IN_198: usize = 28; const OUT_198: usize = 2; -fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_28, __v_28, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = (__v_17 - __v_15); let __v_32: G = (__v_28 - __v_28); let __v_33: G = (__v_31 * __v_27); let __v_34: G = G::from_u64(7); let __v_35: G = (__v_32 * __v_28); let __v_36: G = (__v_34 * __v_35); let __v_37: G = (__v_33 + __v_36); let __v_38: G = (__v_31 * __v_28); let __v_39: G = (__v_32 * __v_27); let __v_40: G = (__v_38 + __v_39); let __v_41: G = (__v_21 * __v_37); let __v_42: G = (__v_22 * __v_40); let __v_43: G = (__v_34 * __v_42); let __v_44: G = (__v_41 + __v_43); let __v_45: G = (__v_21 * __v_40); let __v_46: G = (__v_22 * __v_37); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_18 - __v_16); let __v_49: G = (__v_48 * __v_27); let __v_50: G = (__v_49 + __v_36); let __v_51: G = (__v_48 * __v_28); let __v_52: G = (__v_51 + __v_39); let __v_53: G = (__v_21 * __v_50); let __v_54: G = (__v_22 * __v_52); let __v_55: G = (__v_34 * __v_54); let __v_56: G = (__v_53 + __v_55); let __v_57: G = (__v_21 * __v_52); let __v_58: G = (__v_22 * __v_50); let __v_59: G = (__v_57 + __v_58); let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; let __v_63: G = __loaded[3]; match __v_60.as_canonical_u64() { 1u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_64]; 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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_64]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = (__v_65 - __v_67); let __v_70: G = (__v_66 - __v_68); let __v_71: G = (__v_69 + __v_44); let __v_72: G = (__v_70 + __v_47); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_75]; 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_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_75]; 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_78: G = __r_arr[0]; let __v_79: G = __r_arr[1]; let __v_80: G = (__v_76 - __v_78); let __v_81: G = (__v_77 - __v_79); let __v_82: G = (__v_80 + __v_56); let __v_83: G = (__v_81 + __v_59); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_84, __v_85]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_29, __v_30, __v_25, __v_26, __v_2, __v_64, __v_65, __v_64, __v_3, __v_3, __v_66, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_44, __v_47, __v_56, __v_59, __v_11, __v_28, __v_12, __v_28, __v_13, __v_28, __v_14, __v_28, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_67, __v_68]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } +fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_28, __v_28, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __v_17 - __v_15; let __v_32: G = __v_28 - __v_28; let __v_33: G = __v_31 * __v_27; let __v_34: G = G::from_u64(7); let __v_35: G = __v_32 * __v_28; let __v_36: G = __v_34 * __v_35; let __v_37: G = __v_33 + __v_36; let __v_38: G = __v_31 * __v_28; let __v_39: G = __v_32 * __v_27; let __v_40: G = __v_38 + __v_39; let __v_41: G = __v_21 * __v_37; let __v_42: G = __v_22 * __v_40; let __v_43: G = __v_34 * __v_42; let __v_44: G = __v_41 + __v_43; let __v_45: G = __v_21 * __v_40; let __v_46: G = __v_22 * __v_37; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_18 - __v_16; let __v_49: G = __v_48 * __v_27; let __v_50: G = __v_49 + __v_36; let __v_51: G = __v_48 * __v_28; let __v_52: G = __v_51 + __v_39; let __v_53: G = __v_21 * __v_50; let __v_54: G = __v_22 * __v_52; let __v_55: G = __v_34 * __v_54; let __v_56: G = __v_53 + __v_55; let __v_57: G = __v_21 * __v_52; let __v_58: G = __v_22 * __v_50; let __v_59: G = __v_57 + __v_58; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; let __v_63: G = __loaded[3]; match __v_60.as_canonical_u64() { 1u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_64]; 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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_64]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = __v_65 - __v_67; let __v_70: G = __v_66 - __v_68; let __v_71: G = __v_69 + __v_44; let __v_72: G = __v_70 + __v_47; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_75]; 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_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_75]; 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_78: G = __r_arr[0]; let __v_79: G = __r_arr[1]; let __v_80: G = __v_76 - __v_78; let __v_81: G = __v_77 - __v_79; let __v_82: G = __v_80 + __v_56; let __v_83: G = __v_81 + __v_59; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_84, __v_85]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_29, __v_30, __v_25, __v_26, __v_2, __v_64, __v_65, __v_64, __v_3, __v_3, __v_66, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_44, __v_47, __v_56, __v_59, __v_11, __v_28, __v_12, __v_28, __v_13, __v_28, __v_14, __v_28, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_67, __v_68]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } const INPUT_SIZE_199: usize = 8; const IN_199: usize = 8; const OUT_199: usize = 1; -fn aiur_fn_199(inp: [G; IN_199], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_5, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_4, __v_8, __v_13]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_2, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_1, __v_8, __v_16]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_0, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_18]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_199(inp: [G; IN_199], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_5, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_4, __v_8, __v_13]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_2, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_1, __v_8, __v_16]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_0, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_18]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_200: usize = 5; const IN_200: usize = 5; const OUT_200: usize = 2; -fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_200] = [__v_9, __v_9]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = (__v_3 * __v_6); let __v_10: G = G::from_u64(7); let __v_11: G = (__v_4 * __v_7); let __v_12: G = (__v_10 * __v_11); let __v_13: G = (__v_9 + __v_12); let __v_14: G = (__v_3 * __v_7); let __v_15: G = (__v_4 * __v_6); let __v_16: G = (__v_14 + __v_15); let __v_17: G = (__v_3 * __v_1); let __v_18: G = (__v_4 * __v_2); let __v_19: G = (__v_10 * __v_18); let __v_20: G = (__v_17 + __v_19); let __v_21: G = (__v_3 * __v_2); let __v_22: G = (__v_4 * __v_1); let __v_23: G = (__v_21 + __v_22); let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = (__v_13 + __v_24); let __v_27: G = (__v_16 + __v_25); let __ret: [G; OUT_200] = [__v_26, __v_27]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_200] = [__v_9, __v_9]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = __v_3 * __v_6; let __v_10: G = G::from_u64(7); let __v_11: G = __v_4 * __v_7; let __v_12: G = __v_10 * __v_11; let __v_13: G = __v_9 + __v_12; let __v_14: G = __v_3 * __v_7; let __v_15: G = __v_4 * __v_6; let __v_16: G = __v_14 + __v_15; let __v_17: G = __v_3 * __v_1; let __v_18: G = __v_4 * __v_2; let __v_19: G = __v_10 * __v_18; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_3 * __v_2; let __v_22: G = __v_4 * __v_1; let __v_23: G = __v_21 + __v_22; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, &__args[..])?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __v_13 + __v_24; let __v_27: G = __v_16 + __v_25; let __ret: [G; OUT_200] = [__v_26, __v_27]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } const INPUT_SIZE_201: usize = 1; const IN_201: usize = 1; const OUT_201: usize = 1; -fn aiur_fn_201(inp: [G; IN_201], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_201(inp: [G; IN_201], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_202: usize = 4; const IN_202: usize = 4; const OUT_202: usize = 2; -fn aiur_fn_202(inp: [G; IN_202], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_202] = [__v_5, __v_5]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_0.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_202] = [__v_5, __v_5]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_6, __v_8]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_202(inp: [G; IN_202], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_202] = [__v_5, __v_5]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_0.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_202] = [__v_5, __v_5]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_6, __v_8]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_203: usize = 20; const IN_203: usize = 20; const OUT_203: usize = 1; -fn aiur_fn_203(inp: [G; IN_203], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; match __v_20.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_31]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2, __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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(32); let __v_33: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_31), (&__v_32)) } else { aiur::execute::bytes2_less_than_value(__v_31, __v_32, record) }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_9]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_38, __v_39]; 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_40: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_38, __v_34]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_5, __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_42: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_42, __v_39]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_42, __v_34]; 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_44: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_1, __v_9]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_45.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_47, __v_50]; 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_51: G = __r_arr[0]; break '__mc_0 [__v_49, __v_51]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }; let __v_47: G = __mc_out___mc_0[0]; let __v_48: G = __mc_out___mc_0[1]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_40]; 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_49: G = __r_arr[0]; let __v_50: G = (__v_49 - __v_27); let __v_51: G = G::from_bool((__v_50 == G::ZERO)); let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_41]; 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 __v_54: G = (__v_53 - __v_27); let __v_55: G = G::from_bool((__v_54 == G::ZERO)); if (__v_55 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_43]; 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 __v_57: G = (__v_56 - __v_29); let __v_58: G = G::from_bool((__v_57 == G::ZERO)); if (__v_58 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_44]; 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_59: G = __r_arr[0]; let __v_60: G = (__v_59 - __v_29); let __v_61: G = G::from_bool((__v_60 == G::ZERO)); if (__v_61 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_47]; 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_62: G = __r_arr[0]; let __v_63: G = (__v_62 - __v_28); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); if (__v_64 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_48]; 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_65: G = __r_arr[0]; let __v_66: G = (__v_65 - __v_28); let __v_67: G = G::from_bool((__v_66 == G::ZERO)); if (__v_67 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); let __v_71: G = (__v_68 - __v_52); let __v_72: G = (__v_69 - __v_70); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = aiur::execute::g_inverse_value(__v_73); let __v_75: G = (__v_73 * __v_74); let __v_76: G = (__v_75 - __v_52); let __v_77: G = (__v_73 * __v_76); if (__v_77 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_78: G = (__v_74 * __v_76); if (__v_78 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_79: G = (__v_18 - __v_52); let __v_80: G = (__v_19 - __v_70); let __v_81: G = (__v_79 * __v_79); let __v_82: G = G::from_u64(7); let __v_83: G = (__v_80 * __v_80); let __v_84: G = (__v_82 * __v_83); let __v_85: G = (__v_81 - __v_84); let __v_86: G = aiur::execute::g_inverse_value(__v_85); let __v_87: G = (__v_85 * __v_86); let __v_88: G = (__v_87 - __v_52); let __v_89: G = (__v_85 * __v_88); if (__v_89 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_90: G = (__v_86 * __v_88); if (__v_90 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_91: G = (__v_79 * __v_86); let __v_92: G = (__v_70 - __v_80); let __v_93: G = (__v_92 * __v_86); let __v_94: G = (__v_71 * __v_91); let __v_95: G = (__v_72 * __v_93); let __v_96: G = (__v_82 * __v_95); let __v_97: G = (__v_94 + __v_96); let __v_98: G = (__v_71 * __v_93); let __v_99: G = (__v_72 * __v_91); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_18 - __v_74); let __v_102: G = (__v_101 * __v_101); let __v_103: G = (__v_102 - __v_84); let __v_104: G = aiur::execute::g_inverse_value(__v_103); let __v_105: G = (__v_103 * __v_104); let __v_106: G = (__v_105 - __v_52); let __v_107: G = (__v_103 * __v_106); if (__v_107 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_108: G = (__v_104 * __v_106); if (__v_108 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_109: G = (__v_101 * __v_104); let __v_110: G = (__v_92 * __v_104); let __v_111: G = (__v_71 * __v_109); let __v_112: G = (__v_72 * __v_110); let __v_113: G = (__v_82 * __v_112); let __v_114: G = (__v_111 + __v_113); let __v_115: G = (__v_71 * __v_110); let __v_116: G = (__v_72 * __v_109); let __v_117: G = (__v_115 + __v_116); let __v_118: G = (__v_71 * __v_71); let __v_119: G = (__v_72 * __v_72); let __v_120: G = (__v_82 * __v_119); let __v_121: G = (__v_118 - __v_120); let __v_122: G = aiur::execute::g_inverse_value(__v_121); let __v_123: G = (__v_121 * __v_122); let __v_124: G = (__v_123 - __v_52); let __v_125: G = (__v_121 * __v_124); if (__v_125 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_122 * __v_124); if (__v_126 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_127: G = (__v_71 * __v_122); let __v_128: G = (__v_70 - __v_72); let __v_129: G = (__v_128 * __v_122); let __v_130: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_131: G = { let __values: [G; 4] = [__v_70, __v_37, __v_70, __v_130]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_132: G = { let __values: [G; 4] = [__v_70, __v_36, __v_70, __v_131]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_133: G = { let __values: [G; 4] = [__v_70, __v_11, __v_70, __v_132]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_134: G = { let __values: [G; 4] = [__v_70, __v_10, __v_70, __v_133]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_135: G = { let __values: [G; 4] = [__v_70, __v_15, __v_70, __v_134]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_136: G = { let __values: [G; 4] = [__v_70, __v_14, __v_70, __v_135]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_137: G = { let __values: [G; 4] = [__v_70, __v_13, __v_70, __v_136]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_138: G = { let __values: [G; 4] = [__v_70, __v_12, __v_70, __v_137]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, (&__args[..]))?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { (*(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188])) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, (&__args[..]))?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { (*(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186])) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_140: G = __r_arr[0]; let __v_141: G = (__v_139 * __v_140); let __v_142: G = aiur::execute::g_inverse_value(__v_141); let __v_143: G = (__v_141 * __v_142); let __v_144: G = (__v_143 - __v_52); let __v_145: G = (__v_141 * __v_144); if (__v_145 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_146: G = (__v_142 * __v_144); if (__v_146 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_70, __v_70, __v_16, __v_17, __v_23, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; let __v_149: G = (__v_36 - __v_10); let __v_150: G = (__v_70 - __v_70); let __v_151: G = (__v_149 * __v_142); let __v_152: G = (__v_150 * __v_70); let __v_153: G = (__v_82 * __v_152); let __v_154: G = (__v_151 + __v_153); let __v_155: G = (__v_149 * __v_70); let __v_156: G = (__v_150 * __v_142); let __v_157: G = (__v_155 + __v_156); let __v_158: G = (__v_114 * __v_154); let __v_159: G = (__v_117 * __v_157); let __v_160: G = (__v_82 * __v_159); let __v_161: G = (__v_158 + __v_160); let __v_162: G = (__v_114 * __v_157); let __v_163: G = (__v_117 * __v_154); let __v_164: G = (__v_162 + __v_163); let __v_165: G = (__v_37 - __v_11); let __v_166: G = (__v_165 * __v_142); let __v_167: G = (__v_166 + __v_153); let __v_168: G = (__v_165 * __v_70); let __v_169: G = (__v_168 + __v_156); let __v_170: G = (__v_114 * __v_167); let __v_171: G = (__v_117 * __v_169); let __v_172: G = (__v_82 * __v_171); let __v_173: G = (__v_170 + __v_172); let __v_174: G = (__v_114 * __v_169); let __v_175: G = (__v_117 * __v_167); let __v_176: G = (__v_174 + __v_175); let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_177: G = __loaded[0]; let __v_178: G = __loaded[1]; let __v_179: G = __loaded[2]; let __v_180: G = __loaded[3]; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_177.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_44, __v_181]; 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_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_43, __v_181]; 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_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; let __v_186: G = (__v_182 - __v_184); let __v_187: G = (__v_183 - __v_185); let __v_188: G = (__v_186 + __v_161); let __v_189: G = (__v_187 + __v_164); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_190: G = __r_arr[0]; let __v_191: G = __r_arr[1]; let __v_192: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_44, __v_192]; 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_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_43, __v_192]; 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_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = (__v_193 - __v_195); let __v_198: G = (__v_194 - __v_196); let __v_199: G = (__v_197 + __v_173); let __v_200: G = (__v_198 + __v_176); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; break '__mc_1 [__v_201, __v_202]; }, 0u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_25]; 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_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_147, __v_148, __v_16, __v_17, __v_25, __v_181, __v_182, __v_181, __v_26, __v_26, __v_183, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_161, __v_164, __v_173, __v_176, __v_12, __v_70, __v_13, __v_70, __v_14, __v_70, __v_15, __v_70, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; break '__mc_1 [__v_184, __v_185]; }, _ => { return Err(ExecError::MatchNoCase(__v_177.as_canonical_u64())); }, } }; let __v_181: G = __mc_out___mc_1[0]; let __v_182: G = __mc_out___mc_1[1]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_8, __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_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_183, __v_184]; 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_185: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_186]; 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_187: G = __r_arr[0]; let __v_188: G = (__v_187 - __v_35); let __v_189: G = G::from_bool((__v_188 == G::ZERO)); let __v_190: G = G::from_u64(1); if (__v_189 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_186, __v_191, __v_192, __v_190, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __v_195: G = (__v_181 * __v_127); let __v_196: G = G::from_u64(7); let __v_197: G = (__v_182 * __v_129); let __v_198: G = (__v_196 * __v_197); let __v_199: G = (__v_195 + __v_198); let __v_200: G = (__v_181 * __v_129); let __v_201: G = (__v_182 * __v_127); let __v_202: G = (__v_200 + __v_201); let __v_203: G = (__v_199 - __v_193); let __v_204: G = G::from_bool((__v_203 == G::ZERO)); let __v_205: G = (__v_202 - __v_194); let __v_206: G = G::from_bool((__v_205 == G::ZERO)); let __v_207: G = (__v_204 * __v_206); if (__v_207 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __v_208: G = (__v_9 + __v_190); let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_30, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_208, __v_36, __v_37, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, (&__args[..]))?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { (*(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203])) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_209]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } +fn aiur_fn_203(inp: [G; IN_203], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; match __v_20.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_31]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2, __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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(32); let __v_33: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_31, &__v_32) } else { aiur::execute::bytes2_less_than_value(__v_31, __v_32, record) }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_9]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_38, __v_39]; 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_40: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_38, __v_34]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_5, __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_42: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_42, __v_39]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_42, __v_34]; 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_44: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_1, __v_9]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_45.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_47, __v_50]; 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_51: G = __r_arr[0]; break '__mc_0 [__v_49, __v_51]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }; let __v_47: G = __mc_out___mc_0[0]; let __v_48: G = __mc_out___mc_0[1]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_40]; 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_49: G = __r_arr[0]; let __v_50: G = __v_49 - __v_27; let __v_51: G = G::from_bool(__v_50 == G::ZERO); let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_41]; 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 __v_54: G = __v_53 - __v_27; let __v_55: G = G::from_bool(__v_54 == G::ZERO); if (__v_55 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_43]; 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 __v_57: G = __v_56 - __v_29; let __v_58: G = G::from_bool(__v_57 == G::ZERO); if (__v_58 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_44]; 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_59: G = __r_arr[0]; let __v_60: G = __v_59 - __v_29; let __v_61: G = G::from_bool(__v_60 == G::ZERO); if (__v_61 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_47]; 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_62: G = __r_arr[0]; let __v_63: G = __v_62 - __v_28; let __v_64: G = G::from_bool(__v_63 == G::ZERO); if (__v_64 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_48]; 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_65: G = __r_arr[0]; let __v_66: G = __v_65 - __v_28; let __v_67: G = G::from_bool(__v_66 == G::ZERO); if (__v_67 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); let __v_71: G = __v_68 - __v_52; let __v_72: G = __v_69 - __v_70; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = aiur::execute::g_inverse_value(__v_73); let __v_75: G = __v_73 * __v_74; let __v_76: G = __v_75 - __v_52; let __v_77: G = __v_73 * __v_76; if (__v_77 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_78: G = __v_74 * __v_76; if (__v_78 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_79: G = __v_18 - __v_52; let __v_80: G = __v_19 - __v_70; let __v_81: G = __v_79 * __v_79; let __v_82: G = G::from_u64(7); let __v_83: G = __v_80 * __v_80; let __v_84: G = __v_82 * __v_83; let __v_85: G = __v_81 - __v_84; let __v_86: G = aiur::execute::g_inverse_value(__v_85); let __v_87: G = __v_85 * __v_86; let __v_88: G = __v_87 - __v_52; let __v_89: G = __v_85 * __v_88; if (__v_89 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_90: G = __v_86 * __v_88; if (__v_90 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_91: G = __v_79 * __v_86; let __v_92: G = __v_70 - __v_80; let __v_93: G = __v_92 * __v_86; let __v_94: G = __v_71 * __v_91; let __v_95: G = __v_72 * __v_93; let __v_96: G = __v_82 * __v_95; let __v_97: G = __v_94 + __v_96; let __v_98: G = __v_71 * __v_93; let __v_99: G = __v_72 * __v_91; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_18 - __v_74; let __v_102: G = __v_101 * __v_101; let __v_103: G = __v_102 - __v_84; let __v_104: G = aiur::execute::g_inverse_value(__v_103); let __v_105: G = __v_103 * __v_104; let __v_106: G = __v_105 - __v_52; let __v_107: G = __v_103 * __v_106; if (__v_107 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_108: G = __v_104 * __v_106; if (__v_108 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_109: G = __v_101 * __v_104; let __v_110: G = __v_92 * __v_104; let __v_111: G = __v_71 * __v_109; let __v_112: G = __v_72 * __v_110; let __v_113: G = __v_82 * __v_112; let __v_114: G = __v_111 + __v_113; let __v_115: G = __v_71 * __v_110; let __v_116: G = __v_72 * __v_109; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_71 * __v_71; let __v_119: G = __v_72 * __v_72; let __v_120: G = __v_82 * __v_119; let __v_121: G = __v_118 - __v_120; let __v_122: G = aiur::execute::g_inverse_value(__v_121); let __v_123: G = __v_121 * __v_122; let __v_124: G = __v_123 - __v_52; let __v_125: G = __v_121 * __v_124; if (__v_125 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_126: G = __v_122 * __v_124; if (__v_126 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_127: G = __v_71 * __v_122; let __v_128: G = __v_70 - __v_72; let __v_129: G = __v_128 * __v_122; let __v_130: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_131: G = { let __values: [G; 4] = [__v_70, __v_37, __v_70, __v_130]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_132: G = { let __values: [G; 4] = [__v_70, __v_36, __v_70, __v_131]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_133: G = { let __values: [G; 4] = [__v_70, __v_11, __v_70, __v_132]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_134: G = { let __values: [G; 4] = [__v_70, __v_10, __v_70, __v_133]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_135: G = { let __values: [G; 4] = [__v_70, __v_15, __v_70, __v_134]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_136: G = { let __values: [G; 4] = [__v_70, __v_14, __v_70, __v_135]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_137: G = { let __values: [G; 4] = [__v_70, __v_13, __v_70, __v_136]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_138: G = { let __values: [G; 4] = [__v_70, __v_12, __v_70, __v_137]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, &__args[..])?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_140: G = __r_arr[0]; let __v_141: G = __v_139 * __v_140; let __v_142: G = aiur::execute::g_inverse_value(__v_141); let __v_143: G = __v_141 * __v_142; let __v_144: G = __v_143 - __v_52; let __v_145: G = __v_141 * __v_144; if (__v_145 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_146: G = __v_142 * __v_144; if (__v_146 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_70, __v_70, __v_16, __v_17, __v_23, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; let __v_149: G = __v_36 - __v_10; let __v_150: G = __v_70 - __v_70; let __v_151: G = __v_149 * __v_142; let __v_152: G = __v_150 * __v_70; let __v_153: G = __v_82 * __v_152; let __v_154: G = __v_151 + __v_153; let __v_155: G = __v_149 * __v_70; let __v_156: G = __v_150 * __v_142; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_114 * __v_154; let __v_159: G = __v_117 * __v_157; let __v_160: G = __v_82 * __v_159; let __v_161: G = __v_158 + __v_160; let __v_162: G = __v_114 * __v_157; let __v_163: G = __v_117 * __v_154; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_37 - __v_11; let __v_166: G = __v_165 * __v_142; let __v_167: G = __v_166 + __v_153; let __v_168: G = __v_165 * __v_70; let __v_169: G = __v_168 + __v_156; let __v_170: G = __v_114 * __v_167; let __v_171: G = __v_117 * __v_169; let __v_172: G = __v_82 * __v_171; let __v_173: G = __v_170 + __v_172; let __v_174: G = __v_114 * __v_169; let __v_175: G = __v_117 * __v_167; let __v_176: G = __v_174 + __v_175; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_177: G = __loaded[0]; let __v_178: G = __loaded[1]; let __v_179: G = __loaded[2]; let __v_180: G = __loaded[3]; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_177.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_44, __v_181]; 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_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_43, __v_181]; 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_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; let __v_186: G = __v_182 - __v_184; let __v_187: G = __v_183 - __v_185; let __v_188: G = __v_186 + __v_161; let __v_189: G = __v_187 + __v_164; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_190: G = __r_arr[0]; let __v_191: G = __r_arr[1]; let __v_192: G = G::from_u64(1); let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_44, __v_192]; 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_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_43, __v_192]; 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_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = __v_193 - __v_195; let __v_198: G = __v_194 - __v_196; let __v_199: G = __v_197 + __v_173; let __v_200: G = __v_198 + __v_176; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; break '__mc_1 [__v_201, __v_202]; }, 0u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_25]; 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_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_147, __v_148, __v_16, __v_17, __v_25, __v_181, __v_182, __v_181, __v_26, __v_26, __v_183, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_161, __v_164, __v_173, __v_176, __v_12, __v_70, __v_13, __v_70, __v_14, __v_70, __v_15, __v_70, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; break '__mc_1 [__v_184, __v_185]; }, _ => { return Err(ExecError::MatchNoCase(__v_177.as_canonical_u64())); }, } }; let __v_181: G = __mc_out___mc_1[0]; let __v_182: G = __mc_out___mc_1[1]; let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_8, __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_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_183, __v_184]; 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_185: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_186]; 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_187: G = __r_arr[0]; let __v_188: G = __v_187 - __v_35; let __v_189: G = G::from_bool(__v_188 == G::ZERO); let __v_190: G = G::from_u64(1); if (__v_189 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_186, __v_191, __v_192, __v_190, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, &__args[..])?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __v_195: G = __v_181 * __v_127; let __v_196: G = G::from_u64(7); let __v_197: G = __v_182 * __v_129; let __v_198: G = __v_196 * __v_197; let __v_199: G = __v_195 + __v_198; let __v_200: G = __v_181 * __v_129; let __v_201: G = __v_182 * __v_127; let __v_202: G = __v_200 + __v_201; let __v_203: G = __v_199 - __v_193; let __v_204: G = G::from_bool(__v_203 == G::ZERO); let __v_205: G = __v_202 - __v_194; let __v_206: G = G::from_bool(__v_205 == G::ZERO); let __v_207: G = __v_204 * __v_206; if (__v_207 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __v_208: G = __v_9 + __v_190; let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_30, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_208, __v_36, __v_37, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, &__args[..])?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_209]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } const INPUT_SIZE_204: usize = 3; const IN_204: usize = 3; const OUT_204: usize = 2; -fn aiur_fn_204(inp: [G; IN_204], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_204] = [__v_13, __v_13]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_5); let __v_15: G = G::from_u64(65536); let __v_16: G = (__v_15 * __v_6); let __v_17: G = G::from_u64(16777216); let __v_18: G = (__v_17 * __v_7); let __v_19: G = G::from_u64(4294967296); let __v_20: G = (__v_19 * __v_8); let __v_21: G = G::from_u64(1099511627776); let __v_22: G = (__v_21 * __v_9); let __v_23: G = G::from_u64(281474976710656); let __v_24: G = (__v_23 * __v_10); let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = (__v_25 * __v_11); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_22 + __v_27); let __v_29: G = (__v_20 + __v_28); let __v_30: G = (__v_18 + __v_29); let __v_31: G = (__v_16 + __v_30); let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_4 + __v_32); let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); let __v_38: G = G::from_u64(7); let __v_39: G = (__v_1 * __v_36); let __v_40: G = (__v_38 * __v_39); let __v_41: G = (__v_37 + __v_40); let __v_42: G = (__v_0 * __v_36); let __v_43: G = (__v_1 * __v_35); let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_33 + __v_41); let __v_46: G = (__v_34 + __v_44); let __ret: [G; OUT_204] = [__v_45, __v_46]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_204(inp: [G; IN_204], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_204] = [__v_13, __v_13]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = G::from_u64(256); let __v_14: G = __v_13 * __v_5; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_6; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_7; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_8; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_9; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_10; let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = __v_25 * __v_11; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_22 + __v_27; let __v_29: G = __v_20 + __v_28; let __v_30: G = __v_18 + __v_29; let __v_31: G = __v_16 + __v_30; let __v_32: G = __v_14 + __v_31; let __v_33: G = __v_4 + __v_32; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __v_0 * __v_35; let __v_38: G = G::from_u64(7); let __v_39: G = __v_1 * __v_36; let __v_40: G = __v_38 * __v_39; let __v_41: G = __v_37 + __v_40; let __v_42: G = __v_0 * __v_36; let __v_43: G = __v_1 * __v_35; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_33 + __v_41; let __v_46: G = __v_34 + __v_44; let __ret: [G; OUT_204] = [__v_45, __v_46]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_205: usize = 7; const IN_205: usize = 7; const OUT_205: usize = 2; -fn aiur_fn_205(inp: [G; IN_205], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_205] = [__v_0, __v_1]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); let __v_13: G = (__v_4 + __v_11); let __v_14: G = (__v_12 * __v_12); let __v_15: G = G::from_u64(7); let __v_16: G = (__v_13 * __v_13); let __v_17: G = (__v_15 * __v_16); let __v_18: G = (__v_14 - __v_17); let __v_19: G = aiur::execute::g_inverse_value(__v_18); let __v_20: G = (__v_18 * __v_19); let __v_21: G = G::from_u64(1); let __v_22: G = (__v_20 - __v_21); let __v_23: G = (__v_18 * __v_22); let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_25: G = (__v_19 * __v_22); if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_26: G = (__v_12 * __v_19); let __v_27: G = (__v_24 - __v_13); let __v_28: G = (__v_27 * __v_19); let __v_29: G = (__v_0 + __v_26); let __v_30: G = (__v_1 + __v_28); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_205] = [__v_31, __v_32]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_205(inp: [G; IN_205], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_205] = [__v_0, __v_1]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __v_3 + __v_10; let __v_13: G = __v_4 + __v_11; let __v_14: G = __v_12 * __v_12; let __v_15: G = G::from_u64(7); let __v_16: G = __v_13 * __v_13; let __v_17: G = __v_15 * __v_16; let __v_18: G = __v_14 - __v_17; let __v_19: G = aiur::execute::g_inverse_value(__v_18); let __v_20: G = __v_18 * __v_19; let __v_21: G = G::from_u64(1); let __v_22: G = __v_20 - __v_21; let __v_23: G = __v_18 * __v_22; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_25: G = __v_19 * __v_22; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_26: G = __v_12 * __v_19; let __v_27: G = __v_24 - __v_13; let __v_28: G = __v_27 * __v_19; let __v_29: G = __v_0 + __v_26; let __v_30: G = __v_1 + __v_28; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_205] = [__v_31, __v_32]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_206: usize = 1; const IN_206: usize = 1; const OUT_206: usize = 1; -fn aiur_fn_206(inp: [G; IN_206], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_206] = [__v_4]; record.function_queries[206].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); let __v_6: G = (__v_2 * __v_5); let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_8]; record.function_queries[206].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_206(inp: [G; IN_206], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_206] = [__v_4]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_2 - __v_4; let __v_6: G = __v_2 * __v_5; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_8]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_207: usize = 2; const IN_207: usize = 2; const OUT_207: usize = 1; -fn aiur_fn_207(inp: [G; IN_207], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 11] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_207] = [__v_14]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, (&__args[..]))?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { (*(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207])) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_16]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, (&__args[..]))?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { (*(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207])) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 11] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_207] = [__v_18]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_207(inp: [G; IN_207], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 11] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_207] = [__v_14]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, &__args[..])?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_16]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, &__args[..])?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 11] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_207] = [__v_18]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_208: usize = 2; const IN_208: usize = 2; const OUT_208: usize = 1; -fn aiur_fn_208(inp: [G; IN_208], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_208] = [__v_7]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_9]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_208] = [__v_11]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_208(inp: [G; IN_208], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_208] = [__v_7]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_9]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_208] = [__v_11]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_209: usize = 2; const IN_209: usize = 2; const OUT_209: usize = 1; -fn aiur_fn_209(inp: [G; IN_209], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_2: G = G::from_u8(__gb[0]); let __v_3: G = G::from_u8(__gb[1]); let __v_4: G = G::from_u8(__gb[2]); let __v_5: G = G::from_u8(__gb[3]); let __v_6: G = G::from_u8(__gb[4]); let __v_7: G = G::from_u8(__gb[5]); let __v_8: G = G::from_u8(__gb[6]); let __v_9: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_3); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_9); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_2 + __v_29); if (__v_30 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_31: G = G::from_u64(1020); let __v_32: G = (__v_9 - __v_31); let __v_33: G = (__v_8 + __v_32); let __v_34: G = (__v_7 + __v_33); let __v_35: G = (__v_6 + __v_34); let __v_36: G = G::from_bool((__v_35 == G::ZERO)); let __v_37: G = (__v_4 + __v_5); let __v_38: G = (__v_3 + __v_37); let __v_39: G = (__v_2 + __v_38); let __v_40: G = G::from_bool((__v_39 == G::ZERO)); let __v_41: G = G::from_u64(1); let __v_42: G = (__v_41 - __v_40); let __v_43: G = (__v_36 * __v_42); let __v_44: G = (__v_41 - __v_43); if (__v_44 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_45]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_209(inp: [G; IN_209], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_2: G = G::from_u8(__gb[0]); let __v_3: G = G::from_u8(__gb[1]); let __v_4: G = G::from_u8(__gb[2]); let __v_5: G = G::from_u8(__gb[3]); let __v_6: G = G::from_u8(__gb[4]); let __v_7: G = G::from_u8(__gb[5]); let __v_8: G = G::from_u8(__gb[6]); let __v_9: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_3; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_9; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_2 + __v_29; if (__v_30 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_31: G = G::from_u64(1020); let __v_32: G = __v_9 - __v_31; let __v_33: G = __v_8 + __v_32; let __v_34: G = __v_7 + __v_33; let __v_35: G = __v_6 + __v_34; let __v_36: G = G::from_bool(__v_35 == G::ZERO); let __v_37: G = __v_4 + __v_5; let __v_38: G = __v_3 + __v_37; let __v_39: G = __v_2 + __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = G::from_u64(1); let __v_42: G = __v_41 - __v_40; let __v_43: G = __v_36 * __v_42; let __v_44: G = __v_41 - __v_43; if (__v_44 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_45]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_210: usize = 2; const IN_210: usize = 2; const OUT_210: usize = 1; -fn aiur_fn_210(inp: [G; IN_210], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(296, (&__args[..]))?) { [G::ZERO; OUT_296] } else { let (__hash, __hit) = record.function_queries[296].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[296].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { (*(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296])) }; __ret }, _ => { aiur_fn_296::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, (&__args[..]))?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { (*(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211])) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_4]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(296, &__args[..])?) { [G::ZERO; OUT_296] } else { let (__hash, __hit) = record.function_queries[296].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[296].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => { aiur_fn_296::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, &__args[..])?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_4]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_211: usize = 2; const IN_211: usize = 2; const OUT_211: usize = 1; -fn aiur_fn_211(inp: [G; IN_211], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_211] = [__v_1]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, (&__args[..]))?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { (*(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301])) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, (&__args[..]))?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { (*(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211])) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_8]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_211(inp: [G; IN_211], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_211] = [__v_1]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, &__args[..])?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_8]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_212: usize = 5; const IN_212: usize = 5; const OUT_212: usize = 1; -fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(296, (&__args[..]))?) { [G::ZERO; OUT_296] } else { let (__hash, __hit) = record.function_queries[296].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[296].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { (*(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296])) }; __ret }, _ => { aiur_fn_296::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, (&__args[..]))?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { (*(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210])) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_10]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(296, &__args[..])?) { [G::ZERO; OUT_296] } else { let (__hash, __hit) = record.function_queries[296].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[296].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => { aiur_fn_296::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, &__args[..])?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_10]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_213: usize = 2; const IN_213: usize = 2; const OUT_213: usize = 1; -fn aiur_fn_213(inp: [G; IN_213], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_213] = [__v_1]; record.function_queries[213].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, (&__args[..]))?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { (*(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213])) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_4, __v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, (&__args[..]))?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { (*(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212])) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_213] = [__v_9]; record.function_queries[213].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_213(inp: [G; IN_213], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_213] = [__v_1]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, &__args[..])?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_4, __v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, &__args[..])?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_213] = [__v_9]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_214: usize = 2; const IN_214: usize = 2; const OUT_214: usize = 1; -fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_4]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_4]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_215: usize = 2; const IN_215: usize = 2; const OUT_215: usize = 1; -fn aiur_fn_215(inp: [G; IN_215], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_215] = [__v_1]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, (&__args[..]))?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { (*(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301])) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_17]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_215(inp: [G; IN_215], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_215] = [__v_1]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_17]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_216: usize = 4; const IN_216: usize = 4; const OUT_216: usize = 5; -fn aiur_fn_216(inp: [G; IN_216], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(214, (&__args[..]))?) { [G::ZERO; OUT_214] } else { let (__hash, __hit) = record.function_queries[214].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[214].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { (*(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214])) }; __ret }, _ => { aiur_fn_214::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, (&__args[..]))?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { (*(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213])) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(117); let __v_15: G = G::from_u64(108); let __v_16: G = G::from_u64(116); let __v_17: G = G::from_u64(105); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(114); let __v_22: G = G::from_u64(107); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(48); let __v_26: G = { let __values: [G; 3] = [__v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_12, __v_24, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_12, __v_23, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_29: G = { let __values: [G; 3] = [__v_12, __v_22, __v_28]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_30: G = { let __values: [G; 3] = [__v_12, __v_21, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_31: G = { let __values: [G; 3] = [__v_12, __v_20, __v_30]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_32: G = { let __values: [G; 3] = [__v_12, __v_16, __v_31]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_33: G = { let __values: [G; 3] = [__v_12, __v_19, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = { let __values: [G; 3] = [__v_12, __v_18, __v_33]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_35: G = { let __values: [G; 3] = [__v_12, __v_17, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_12, __v_16, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_12, __v_15, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_12, __v_14, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_12, __v_13, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_39, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; let __v_44: G = __r_arr[4]; let __v_45: G = __r_arr[5]; let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; let __v_49: G = __r_arr[9]; let __v_50: G = __r_arr[10]; let __v_51: G = __r_arr[11]; let __v_52: G = __r_arr[12]; let __v_53: G = __r_arr[13]; let __v_54: G = __r_arr[14]; let __v_55: G = __r_arr[15]; let __v_56: G = __r_arr[16]; let __v_57: G = __r_arr[17]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_56, __v_59]; 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_60: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_60, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __v_72: G = __r_arr[11]; let __v_73: G = __r_arr[12]; let __v_74: G = __r_arr[13]; let __v_75: G = __r_arr[14]; let __v_76: G = __r_arr[15]; let __v_77: G = __r_arr[16]; let __v_78: G = __r_arr[17]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_77, __v_80]; 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_81: G = __r_arr[0]; let __v_82: G = G::from_u64(256); let __v_83: G = (__v_82 * __v_41); let __v_84: G = G::from_u64(65536); let __v_85: G = (__v_84 * __v_42); let __v_86: G = G::from_u64(16777216); let __v_87: G = (__v_86 * __v_43); let __v_88: G = G::from_u64(4294967296); let __v_89: G = (__v_88 * __v_44); let __v_90: G = G::from_u64(1099511627776); let __v_91: G = (__v_90 * __v_45); let __v_92: G = G::from_u64(281474976710656); let __v_93: G = (__v_92 * __v_46); let __v_94: G = G::from_u64(72057594037927936); let __v_95: G = (__v_94 * __v_47); let __v_96: G = (__v_93 + __v_95); let __v_97: G = (__v_91 + __v_96); let __v_98: G = (__v_89 + __v_97); let __v_99: G = (__v_87 + __v_98); let __v_100: G = (__v_85 + __v_99); let __v_101: G = (__v_83 + __v_100); let __v_102: G = (__v_40 + __v_101); let __v_103: G = (__v_82 * __v_49); let __v_104: G = (__v_84 * __v_50); let __v_105: G = (__v_86 * __v_51); let __v_106: G = (__v_88 * __v_52); let __v_107: G = (__v_90 * __v_53); let __v_108: G = (__v_92 * __v_54); let __v_109: G = (__v_94 * __v_55); let __v_110: G = (__v_108 + __v_109); let __v_111: G = (__v_107 + __v_110); let __v_112: G = (__v_106 + __v_111); let __v_113: G = (__v_105 + __v_112); let __v_114: G = (__v_104 + __v_113); let __v_115: G = (__v_103 + __v_114); let __v_116: G = (__v_48 + __v_115); let __v_117: G = (__v_82 * __v_62); let __v_118: G = (__v_84 * __v_63); let __v_119: G = (__v_86 * __v_64); let __v_120: G = (__v_88 * __v_65); let __v_121: G = (__v_90 * __v_66); let __v_122: G = (__v_92 * __v_67); let __v_123: G = (__v_94 * __v_68); let __v_124: G = (__v_122 + __v_123); let __v_125: G = (__v_121 + __v_124); let __v_126: G = (__v_120 + __v_125); let __v_127: G = (__v_119 + __v_126); let __v_128: G = (__v_118 + __v_127); let __v_129: G = (__v_117 + __v_128); let __v_130: G = (__v_61 + __v_129); let __v_131: G = (__v_82 * __v_70); let __v_132: G = (__v_84 * __v_71); let __v_133: G = (__v_86 * __v_72); let __v_134: G = (__v_88 * __v_73); let __v_135: G = (__v_90 * __v_74); let __v_136: G = (__v_92 * __v_75); let __v_137: G = (__v_94 * __v_76); let __v_138: G = (__v_136 + __v_137); let __v_139: G = (__v_135 + __v_138); let __v_140: G = (__v_134 + __v_139); let __v_141: G = (__v_133 + __v_140); let __v_142: G = (__v_132 + __v_141); let __v_143: G = (__v_131 + __v_142); let __v_144: G = (__v_69 + __v_143); let __ret: [G; OUT_216] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_216(inp: [G; IN_216], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(214, &__args[..])?) { [G::ZERO; OUT_214] } else { let (__hash, __hit) = record.function_queries[214].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[214].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => { aiur_fn_214::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, &__args[..])?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(117); let __v_15: G = G::from_u64(108); let __v_16: G = G::from_u64(116); let __v_17: G = G::from_u64(105); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(114); let __v_22: G = G::from_u64(107); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(48); let __v_26: G = { let __values: [G; 3] = [__v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_12, __v_24, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_12, __v_23, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_29: G = { let __values: [G; 3] = [__v_12, __v_22, __v_28]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_30: G = { let __values: [G; 3] = [__v_12, __v_21, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_31: G = { let __values: [G; 3] = [__v_12, __v_20, __v_30]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_32: G = { let __values: [G; 3] = [__v_12, __v_16, __v_31]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_33: G = { let __values: [G; 3] = [__v_12, __v_19, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = { let __values: [G; 3] = [__v_12, __v_18, __v_33]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_35: G = { let __values: [G; 3] = [__v_12, __v_17, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_12, __v_16, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_12, __v_15, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_12, __v_14, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_12, __v_13, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_39, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; let __v_44: G = __r_arr[4]; let __v_45: G = __r_arr[5]; let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; let __v_49: G = __r_arr[9]; let __v_50: G = __r_arr[10]; let __v_51: G = __r_arr[11]; let __v_52: G = __r_arr[12]; let __v_53: G = __r_arr[13]; let __v_54: G = __r_arr[14]; let __v_55: G = __r_arr[15]; let __v_56: G = __r_arr[16]; let __v_57: G = __r_arr[17]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_56, __v_59]; 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_60: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_60, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __v_72: G = __r_arr[11]; let __v_73: G = __r_arr[12]; let __v_74: G = __r_arr[13]; let __v_75: G = __r_arr[14]; let __v_76: G = __r_arr[15]; let __v_77: G = __r_arr[16]; let __v_78: G = __r_arr[17]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_77, __v_80]; 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_81: G = __r_arr[0]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_41; let __v_84: G = G::from_u64(65536); let __v_85: G = __v_84 * __v_42; let __v_86: G = G::from_u64(16777216); let __v_87: G = __v_86 * __v_43; let __v_88: G = G::from_u64(4294967296); let __v_89: G = __v_88 * __v_44; let __v_90: G = G::from_u64(1099511627776); let __v_91: G = __v_90 * __v_45; let __v_92: G = G::from_u64(281474976710656); let __v_93: G = __v_92 * __v_46; let __v_94: G = G::from_u64(72057594037927936); let __v_95: G = __v_94 * __v_47; let __v_96: G = __v_93 + __v_95; let __v_97: G = __v_91 + __v_96; let __v_98: G = __v_89 + __v_97; let __v_99: G = __v_87 + __v_98; let __v_100: G = __v_85 + __v_99; let __v_101: G = __v_83 + __v_100; let __v_102: G = __v_40 + __v_101; let __v_103: G = __v_82 * __v_49; let __v_104: G = __v_84 * __v_50; let __v_105: G = __v_86 * __v_51; let __v_106: G = __v_88 * __v_52; let __v_107: G = __v_90 * __v_53; let __v_108: G = __v_92 * __v_54; let __v_109: G = __v_94 * __v_55; let __v_110: G = __v_108 + __v_109; let __v_111: G = __v_107 + __v_110; let __v_112: G = __v_106 + __v_111; let __v_113: G = __v_105 + __v_112; let __v_114: G = __v_104 + __v_113; let __v_115: G = __v_103 + __v_114; let __v_116: G = __v_48 + __v_115; let __v_117: G = __v_82 * __v_62; let __v_118: G = __v_84 * __v_63; let __v_119: G = __v_86 * __v_64; let __v_120: G = __v_88 * __v_65; let __v_121: G = __v_90 * __v_66; let __v_122: G = __v_92 * __v_67; let __v_123: G = __v_94 * __v_68; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_121 + __v_124; let __v_126: G = __v_120 + __v_125; let __v_127: G = __v_119 + __v_126; let __v_128: G = __v_118 + __v_127; let __v_129: G = __v_117 + __v_128; let __v_130: G = __v_61 + __v_129; let __v_131: G = __v_82 * __v_70; let __v_132: G = __v_84 * __v_71; let __v_133: G = __v_86 * __v_72; let __v_134: G = __v_88 * __v_73; let __v_135: G = __v_90 * __v_74; let __v_136: G = __v_92 * __v_75; let __v_137: G = __v_94 * __v_76; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_135 + __v_138; let __v_140: G = __v_134 + __v_139; let __v_141: G = __v_133 + __v_140; let __v_142: G = __v_132 + __v_141; let __v_143: G = __v_131 + __v_142; let __v_144: G = __v_69 + __v_143; let __ret: [G; OUT_216] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_217: usize = 5; const IN_217: usize = 5; const OUT_217: usize = 5; -fn aiur_fn_217(inp: [G; IN_217], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_5: G = G::from_u8(__gb[0]); let __v_6: G = G::from_u8(__gb[1]); let __v_7: G = G::from_u8(__gb[2]); let __v_8: G = G::from_u8(__gb[3]); let __v_9: G = G::from_u8(__gb[4]); let __v_10: G = G::from_u8(__gb[5]); let __v_11: G = G::from_u8(__gb[6]); let __v_12: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_11; let __vj = __v_12; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_6); let __v_15: G = G::from_u64(65536); let __v_16: G = (__v_15 * __v_7); let __v_17: G = G::from_u64(16777216); let __v_18: G = (__v_17 * __v_8); let __v_19: G = G::from_u64(4294967296); let __v_20: G = (__v_19 * __v_9); let __v_21: G = G::from_u64(1099511627776); let __v_22: G = (__v_21 * __v_10); let __v_23: G = G::from_u64(281474976710656); let __v_24: G = (__v_23 * __v_11); let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = (__v_25 * __v_12); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_22 + __v_27); let __v_29: G = (__v_20 + __v_28); let __v_30: G = (__v_18 + __v_29); let __v_31: G = (__v_16 + __v_30); let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_5 + __v_32); if (__v_33 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_34: G = G::from_u64(1020); let __v_35: G = (__v_12 - __v_34); let __v_36: G = (__v_11 + __v_35); let __v_37: G = (__v_10 + __v_36); let __v_38: G = (__v_9 + __v_37); let __v_39: G = G::from_bool((__v_38 == G::ZERO)); let __v_40: G = (__v_7 + __v_8); let __v_41: G = (__v_6 + __v_40); let __v_42: G = (__v_5 + __v_41); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); let __v_44: G = G::from_u64(1); let __v_45: G = (__v_44 - __v_43); let __v_46: G = (__v_39 * __v_45); let __v_47: G = (__v_44 - __v_46); if (__v_47 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, (&__args[..]))?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { (*(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181])) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 3] = [__v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, (&__args[..]))?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { (*(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134])) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_49, __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_52: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_52, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, (&__args[..]))?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { (*(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181])) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_71, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __v_83: G = __r_arr[11]; let __v_84: G = __r_arr[12]; let __v_85: G = __r_arr[13]; let __v_86: G = __r_arr[14]; let __v_87: G = __r_arr[15]; let __v_88: G = __r_arr[16]; let __v_89: G = __r_arr[17]; let __v_90: G = (__v_13 * __v_54); let __v_91: G = (__v_15 * __v_55); let __v_92: G = (__v_17 * __v_56); let __v_93: G = (__v_19 * __v_57); let __v_94: G = (__v_21 * __v_58); let __v_95: G = (__v_23 * __v_59); let __v_96: G = (__v_25 * __v_60); let __v_97: G = (__v_95 + __v_96); let __v_98: G = (__v_94 + __v_97); let __v_99: G = (__v_93 + __v_98); let __v_100: G = (__v_92 + __v_99); let __v_101: G = (__v_91 + __v_100); let __v_102: G = (__v_90 + __v_101); let __v_103: G = (__v_53 + __v_102); let __v_104: G = (__v_13 * __v_62); let __v_105: G = (__v_15 * __v_63); let __v_106: G = (__v_17 * __v_64); let __v_107: G = (__v_19 * __v_65); let __v_108: G = (__v_21 * __v_66); let __v_109: G = (__v_23 * __v_67); let __v_110: G = (__v_25 * __v_68); let __v_111: G = (__v_109 + __v_110); let __v_112: G = (__v_108 + __v_111); let __v_113: G = (__v_107 + __v_112); let __v_114: G = (__v_106 + __v_113); let __v_115: G = (__v_105 + __v_114); let __v_116: G = (__v_104 + __v_115); let __v_117: G = (__v_61 + __v_116); let __v_118: G = (__v_13 * __v_73); let __v_119: G = (__v_15 * __v_74); let __v_120: G = (__v_17 * __v_75); let __v_121: G = (__v_19 * __v_76); let __v_122: G = (__v_21 * __v_77); let __v_123: G = (__v_23 * __v_78); let __v_124: G = (__v_25 * __v_79); let __v_125: G = (__v_123 + __v_124); let __v_126: G = (__v_122 + __v_125); let __v_127: G = (__v_121 + __v_126); let __v_128: G = (__v_120 + __v_127); let __v_129: G = (__v_119 + __v_128); let __v_130: G = (__v_118 + __v_129); let __v_131: G = (__v_72 + __v_130); let __v_132: G = (__v_13 * __v_81); let __v_133: G = (__v_15 * __v_82); let __v_134: G = (__v_17 * __v_83); let __v_135: G = (__v_19 * __v_84); let __v_136: G = (__v_21 * __v_85); let __v_137: G = (__v_23 * __v_86); let __v_138: G = (__v_25 * __v_87); let __v_139: G = (__v_137 + __v_138); let __v_140: G = (__v_136 + __v_139); let __v_141: G = (__v_135 + __v_140); let __v_142: G = (__v_134 + __v_141); let __v_143: G = (__v_133 + __v_142); let __v_144: G = (__v_132 + __v_143); let __v_145: G = (__v_80 + __v_144); let __ret: [G; OUT_217] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_217(inp: [G; IN_217], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_5: G = G::from_u8(__gb[0]); let __v_6: G = G::from_u8(__gb[1]); let __v_7: G = G::from_u8(__gb[2]); let __v_8: G = G::from_u8(__gb[3]); let __v_9: G = G::from_u8(__gb[4]); let __v_10: G = G::from_u8(__gb[5]); let __v_11: G = G::from_u8(__gb[6]); let __v_12: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_11; let __vj = __v_12; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_13: G = G::from_u64(256); let __v_14: G = __v_13 * __v_6; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_7; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_8; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_9; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_10; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_11; let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = __v_25 * __v_12; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_22 + __v_27; let __v_29: G = __v_20 + __v_28; let __v_30: G = __v_18 + __v_29; let __v_31: G = __v_16 + __v_30; let __v_32: G = __v_14 + __v_31; let __v_33: G = __v_5 + __v_32; if (__v_33 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_34: G = G::from_u64(1020); let __v_35: G = __v_12 - __v_34; let __v_36: G = __v_11 + __v_35; let __v_37: G = __v_10 + __v_36; let __v_38: G = __v_9 + __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = __v_7 + __v_8; let __v_41: G = __v_6 + __v_40; let __v_42: G = __v_5 + __v_41; let __v_43: G = G::from_bool(__v_42 == G::ZERO); let __v_44: G = G::from_u64(1); let __v_45: G = __v_44 - __v_43; let __v_46: G = __v_39 * __v_45; let __v_47: G = __v_44 - __v_46; if (__v_47 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 3] = [__v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_49, __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_52: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_52, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_71, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __v_83: G = __r_arr[11]; let __v_84: G = __r_arr[12]; let __v_85: G = __r_arr[13]; let __v_86: G = __r_arr[14]; let __v_87: G = __r_arr[15]; let __v_88: G = __r_arr[16]; let __v_89: G = __r_arr[17]; let __v_90: G = __v_13 * __v_54; let __v_91: G = __v_15 * __v_55; let __v_92: G = __v_17 * __v_56; let __v_93: G = __v_19 * __v_57; let __v_94: G = __v_21 * __v_58; let __v_95: G = __v_23 * __v_59; let __v_96: G = __v_25 * __v_60; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_94 + __v_97; let __v_99: G = __v_93 + __v_98; let __v_100: G = __v_92 + __v_99; let __v_101: G = __v_91 + __v_100; let __v_102: G = __v_90 + __v_101; let __v_103: G = __v_53 + __v_102; let __v_104: G = __v_13 * __v_62; let __v_105: G = __v_15 * __v_63; let __v_106: G = __v_17 * __v_64; let __v_107: G = __v_19 * __v_65; let __v_108: G = __v_21 * __v_66; let __v_109: G = __v_23 * __v_67; let __v_110: G = __v_25 * __v_68; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_108 + __v_111; let __v_113: G = __v_107 + __v_112; let __v_114: G = __v_106 + __v_113; let __v_115: G = __v_105 + __v_114; let __v_116: G = __v_104 + __v_115; let __v_117: G = __v_61 + __v_116; let __v_118: G = __v_13 * __v_73; let __v_119: G = __v_15 * __v_74; let __v_120: G = __v_17 * __v_75; let __v_121: G = __v_19 * __v_76; let __v_122: G = __v_21 * __v_77; let __v_123: G = __v_23 * __v_78; let __v_124: G = __v_25 * __v_79; let __v_125: G = __v_123 + __v_124; let __v_126: G = __v_122 + __v_125; let __v_127: G = __v_121 + __v_126; let __v_128: G = __v_120 + __v_127; let __v_129: G = __v_119 + __v_128; let __v_130: G = __v_118 + __v_129; let __v_131: G = __v_72 + __v_130; let __v_132: G = __v_13 * __v_81; let __v_133: G = __v_15 * __v_82; let __v_134: G = __v_17 * __v_83; let __v_135: G = __v_19 * __v_84; let __v_136: G = __v_21 * __v_85; let __v_137: G = __v_23 * __v_86; let __v_138: G = __v_25 * __v_87; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_136 + __v_139; let __v_141: G = __v_135 + __v_140; let __v_142: G = __v_134 + __v_141; let __v_143: G = __v_133 + __v_142; let __v_144: G = __v_132 + __v_143; let __v_145: G = __v_80 + __v_144; let __ret: [G; OUT_217] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_218: usize = 2; const IN_218: usize = 2; const OUT_218: usize = 1; -fn aiur_fn_218(inp: [G; IN_218], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_218] = [__v_8]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { if (__v_3 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_8]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_218(inp: [G; IN_218], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_218] = [__v_8]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { if (__v_3 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_8]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_219: usize = 2; const IN_219: usize = 2; const OUT_219: usize = 1; -fn aiur_fn_219(inp: [G; IN_219], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = G::from_u64(1); if (__v_12 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_13 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_14 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_15 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_16 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_17 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_18 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_19 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_20 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_219] = [__v_22]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_24]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_219(inp: [G; IN_219], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = G::from_u64(1); if (__v_12 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_13 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_14 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_15 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_16 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_17 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_18 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_19 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_20 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_219] = [__v_22]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, &__args[..])?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_24]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_220: usize = 2; const IN_220: usize = 2; const OUT_220: usize = 1; -fn aiur_fn_220(inp: [G; IN_220], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_220] = [__v_8]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, (&__args[..]))?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { (*(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220])) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_220] = [__v_10]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_220(inp: [G; IN_220], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_220] = [__v_8]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, &__args[..])?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, &__args[..])?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_220] = [__v_10]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_221: usize = 2; const IN_221: usize = 2; const OUT_221: usize = 1; -fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_221] = [__v_8]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; let __v_43: G = __loaded[3]; let __v_44: G = __loaded[4]; let __v_45: G = __loaded[5]; let __v_46: G = __loaded[6]; let __v_47: G = __loaded[7]; let __v_48: G = __loaded[8]; let __v_49: G = __loaded[9]; let __v_50: G = __loaded[10]; let __v_51: G = __loaded[11]; let __v_52: G = __loaded[12]; let __v_53: G = __loaded[13]; let __v_54: G = __loaded[14]; let __v_55: G = __loaded[15]; let __v_56: G = __loaded[16]; let __v_57: G = __loaded[17]; let __v_58: G = __loaded[18]; let __v_59: G = __loaded[19]; let __v_60: G = __loaded[20]; let __v_61: G = __loaded[21]; let __v_62: G = __loaded[22]; let __v_63: G = __loaded[23]; let __v_64: G = __loaded[24]; let __v_65: G = __loaded[25]; let __v_66: G = __loaded[26]; let __v_67: G = __loaded[27]; let __v_68: G = __loaded[28]; let __v_69: G = __loaded[29]; let __v_70: G = __loaded[30]; let __v_71: G = __loaded[31]; let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; if (__v_74 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; if (__v_75 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, (&__args[..]))?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { (*(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221])) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_77]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_221] = [__v_8]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; let __v_43: G = __loaded[3]; let __v_44: G = __loaded[4]; let __v_45: G = __loaded[5]; let __v_46: G = __loaded[6]; let __v_47: G = __loaded[7]; let __v_48: G = __loaded[8]; let __v_49: G = __loaded[9]; let __v_50: G = __loaded[10]; let __v_51: G = __loaded[11]; let __v_52: G = __loaded[12]; let __v_53: G = __loaded[13]; let __v_54: G = __loaded[14]; let __v_55: G = __loaded[15]; let __v_56: G = __loaded[16]; let __v_57: G = __loaded[17]; let __v_58: G = __loaded[18]; let __v_59: G = __loaded[19]; let __v_60: G = __loaded[20]; let __v_61: G = __loaded[21]; let __v_62: G = __loaded[22]; let __v_63: G = __loaded[23]; let __v_64: G = __loaded[24]; let __v_65: G = __loaded[25]; let __v_66: G = __loaded[26]; let __v_67: G = __loaded[27]; let __v_68: G = __loaded[28]; let __v_69: G = __loaded[29]; let __v_70: G = __loaded[30]; let __v_71: G = __loaded[31]; let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; if (__v_74 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; if (__v_75 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, &__args[..])?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_77]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_222: usize = 1; const IN_222: usize = 1; const OUT_222: usize = 2; -fn aiur_fn_222(inp: [G; IN_222], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_222] = [__v_2, __v_3]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, (&__args[..]))?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { (*(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222])) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_222] = [__v_9, __v_10]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_222(inp: [G; IN_222], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_222] = [__v_2, __v_3]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, &__args[..])?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_222] = [__v_9, __v_10]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_223: usize = 7; const IN_223: usize = 7; const OUT_223: usize = 2; -fn aiur_fn_223(inp: [G; IN_223], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_223] = [__v_0, __v_1]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = (__v_3 + __v_18); let __v_21: G = (__v_4 + __v_19); let __v_22: G = (__v_20 * __v_20); let __v_23: G = G::from_u64(7); let __v_24: G = (__v_21 * __v_21); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_22 - __v_25); let __v_27: G = aiur::execute::g_inverse_value(__v_26); let __v_28: G = (__v_26 * __v_27); let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = (__v_26 * __v_30); let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_33: G = (__v_27 * __v_30); if (__v_33 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_34: G = (__v_20 * __v_27); let __v_35: G = (__v_32 - __v_21); let __v_36: G = (__v_35 * __v_27); let __v_37: G = G::from_u64(256); let __v_38: G = (__v_37 * __v_10); let __v_39: G = G::from_u64(65536); let __v_40: G = (__v_39 * __v_11); let __v_41: G = G::from_u64(16777216); let __v_42: G = (__v_41 * __v_12); let __v_43: G = G::from_u64(4294967296); let __v_44: G = (__v_43 * __v_13); let __v_45: G = G::from_u64(1099511627776); let __v_46: G = (__v_45 * __v_14); let __v_47: G = G::from_u64(281474976710656); let __v_48: G = (__v_47 * __v_15); let __v_49: G = G::from_u64(72057594037927936); let __v_50: G = (__v_49 * __v_16); let __v_51: G = (__v_48 + __v_50); let __v_52: G = (__v_46 + __v_51); let __v_53: G = (__v_44 + __v_52); let __v_54: G = (__v_42 + __v_53); let __v_55: G = (__v_40 + __v_54); let __v_56: G = (__v_38 + __v_55); let __v_57: G = (__v_9 + __v_56); let __v_58: G = (__v_34 * __v_57); let __v_59: G = (__v_36 * __v_32); let __v_60: G = (__v_23 * __v_59); let __v_61: G = (__v_58 + __v_60); let __v_62: G = (__v_34 * __v_32); let __v_63: G = (__v_36 * __v_57); let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_0 + __v_61); let __v_66: G = (__v_1 + __v_64); let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, (&__args[..]))?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { (*(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223])) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_223] = [__v_67, __v_68]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_223(inp: [G; IN_223], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_223] = [__v_0, __v_1]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __v_3 + __v_18; let __v_21: G = __v_4 + __v_19; let __v_22: G = __v_20 * __v_20; let __v_23: G = G::from_u64(7); let __v_24: G = __v_21 * __v_21; let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 - __v_25; let __v_27: G = aiur::execute::g_inverse_value(__v_26); let __v_28: G = __v_26 * __v_27; let __v_29: G = G::from_u64(1); let __v_30: G = __v_28 - __v_29; let __v_31: G = __v_26 * __v_30; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_33: G = __v_27 * __v_30; if (__v_33 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_34: G = __v_20 * __v_27; let __v_35: G = __v_32 - __v_21; let __v_36: G = __v_35 * __v_27; let __v_37: G = G::from_u64(256); let __v_38: G = __v_37 * __v_10; let __v_39: G = G::from_u64(65536); let __v_40: G = __v_39 * __v_11; let __v_41: G = G::from_u64(16777216); let __v_42: G = __v_41 * __v_12; let __v_43: G = G::from_u64(4294967296); let __v_44: G = __v_43 * __v_13; let __v_45: G = G::from_u64(1099511627776); let __v_46: G = __v_45 * __v_14; let __v_47: G = G::from_u64(281474976710656); let __v_48: G = __v_47 * __v_15; let __v_49: G = G::from_u64(72057594037927936); let __v_50: G = __v_49 * __v_16; let __v_51: G = __v_48 + __v_50; let __v_52: G = __v_46 + __v_51; let __v_53: G = __v_44 + __v_52; let __v_54: G = __v_42 + __v_53; let __v_55: G = __v_40 + __v_54; let __v_56: G = __v_38 + __v_55; let __v_57: G = __v_9 + __v_56; let __v_58: G = __v_34 * __v_57; let __v_59: G = __v_36 * __v_32; let __v_60: G = __v_23 * __v_59; let __v_61: G = __v_58 + __v_60; let __v_62: G = __v_34 * __v_32; let __v_63: G = __v_36 * __v_57; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_0 + __v_61; let __v_66: G = __v_1 + __v_64; let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, &__args[..])?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_223] = [__v_67, __v_68]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_224: usize = 1; const IN_224: usize = 1; const OUT_224: usize = 1; -fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_225: usize = 1; const IN_225: usize = 1; const OUT_225: usize = 1; -fn aiur_fn_225(inp: [G; IN_225], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_4]; record.function_queries[225].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(224, (&__args[..]))?) { [G::ZERO; OUT_224] } else { let (__hash, __hit) = record.function_queries[224].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[224].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { (*(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224])) }; __ret }, _ => { aiur_fn_224::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, (&__args[..]))?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { (*(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225])) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_225] = [__v_6]; record.function_queries[225].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_225(inp: [G; IN_225], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_4]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(224, &__args[..])?) { [G::ZERO; OUT_224] } else { let (__hash, __hit) = record.function_queries[224].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[224].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => { aiur_fn_224::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, &__args[..])?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_225] = [__v_6]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_226: usize = 1; const IN_226: usize = 1; const OUT_226: usize = 1; -fn aiur_fn_226(inp: [G; IN_226], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_226] = [__v_4]; record.function_queries[226].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_2 + __v_4); let __ret: [G; OUT_226] = [__v_5]; record.function_queries[226].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_226(inp: [G; IN_226], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_226] = [__v_4]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_2 + __v_4; let __ret: [G; OUT_226] = [__v_5]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_227: usize = 1; const IN_227: usize = 1; const OUT_227: usize = 1; -fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_bool((__v_0 == G::ZERO)); let __v_2: G = G::from_u64(0); if (__v_1 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_3: G = G::from_u8(__gb[0]); let __v_4: G = G::from_u8(__gb[1]); let __v_5: G = G::from_u8(__gb[2]); let __v_6: G = G::from_u8(__gb[3]); let __v_7: G = G::from_u8(__gb[4]); let __v_8: G = G::from_u8(__gb[5]); let __v_9: G = G::from_u8(__gb[6]); let __v_10: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_11: G = G::from_u64(256); let __v_12: G = (__v_11 * __v_4); let __v_13: G = G::from_u64(65536); let __v_14: G = (__v_13 * __v_5); let __v_15: G = G::from_u64(16777216); let __v_16: G = (__v_15 * __v_6); let __v_17: G = G::from_u64(4294967296); let __v_18: G = (__v_17 * __v_7); let __v_19: G = G::from_u64(1099511627776); let __v_20: G = (__v_19 * __v_8); let __v_21: G = G::from_u64(281474976710656); let __v_22: G = (__v_21 * __v_9); let __v_23: G = G::from_u64(72057594037927936); let __v_24: G = (__v_23 * __v_10); let __v_25: G = (__v_22 + __v_24); let __v_26: G = (__v_20 + __v_25); let __v_27: G = (__v_18 + __v_26); let __v_28: G = (__v_16 + __v_27); let __v_29: G = (__v_14 + __v_28); let __v_30: G = (__v_12 + __v_29); let __v_31: G = (__v_3 + __v_30); if (__v_31 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1020); let __v_33: G = (__v_10 - __v_32); let __v_34: G = (__v_9 + __v_33); let __v_35: G = (__v_8 + __v_34); let __v_36: G = (__v_7 + __v_35); let __v_37: G = G::from_bool((__v_36 == G::ZERO)); let __v_38: G = (__v_5 + __v_6); let __v_39: G = (__v_4 + __v_38); let __v_40: G = (__v_3 + __v_39); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = G::from_u64(1); let __v_43: G = (__v_42 - __v_41); let __v_44: G = (__v_37 * __v_43); let __v_45: G = (__v_42 - __v_44); if (__v_45 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_46: G = (__v_9 + __v_10); let __v_47: G = (__v_8 + __v_46); let __v_48: G = (__v_7 + __v_47); let __v_49: G = (__v_6 + __v_48); if (__v_49 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_50: G = (__v_5 - __v_42); let __v_51: G = (__v_5 * __v_50); if (__v_51 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_52: G = (__v_3 + __v_4); let __v_53: G = (__v_5 * __v_52); if (__v_53 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_227] = [__v_42]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_bool(__v_0 == G::ZERO); let __v_2: G = G::from_u64(0); if (__v_1 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_3: G = G::from_u8(__gb[0]); let __v_4: G = G::from_u8(__gb[1]); let __v_5: G = G::from_u8(__gb[2]); let __v_6: G = G::from_u8(__gb[3]); let __v_7: G = G::from_u8(__gb[4]); let __v_8: G = G::from_u8(__gb[5]); let __v_9: G = G::from_u8(__gb[6]); let __v_10: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_11: G = G::from_u64(256); let __v_12: G = __v_11 * __v_4; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_5; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_6; let __v_17: G = G::from_u64(4294967296); let __v_18: G = __v_17 * __v_7; let __v_19: G = G::from_u64(1099511627776); let __v_20: G = __v_19 * __v_8; let __v_21: G = G::from_u64(281474976710656); let __v_22: G = __v_21 * __v_9; let __v_23: G = G::from_u64(72057594037927936); let __v_24: G = __v_23 * __v_10; let __v_25: G = __v_22 + __v_24; let __v_26: G = __v_20 + __v_25; let __v_27: G = __v_18 + __v_26; let __v_28: G = __v_16 + __v_27; let __v_29: G = __v_14 + __v_28; let __v_30: G = __v_12 + __v_29; let __v_31: G = __v_3 + __v_30; if (__v_31 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1020); let __v_33: G = __v_10 - __v_32; let __v_34: G = __v_9 + __v_33; let __v_35: G = __v_8 + __v_34; let __v_36: G = __v_7 + __v_35; let __v_37: G = G::from_bool(__v_36 == G::ZERO); let __v_38: G = __v_5 + __v_6; let __v_39: G = __v_4 + __v_38; let __v_40: G = __v_3 + __v_39; let __v_41: G = G::from_bool(__v_40 == G::ZERO); let __v_42: G = G::from_u64(1); let __v_43: G = __v_42 - __v_41; let __v_44: G = __v_37 * __v_43; let __v_45: G = __v_42 - __v_44; if (__v_45 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_46: G = __v_9 + __v_10; let __v_47: G = __v_8 + __v_46; let __v_48: G = __v_7 + __v_47; let __v_49: G = __v_6 + __v_48; if (__v_49 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_50: G = __v_5 - __v_42; let __v_51: G = __v_5 * __v_50; if (__v_51 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_52: G = __v_3 + __v_4; let __v_53: G = __v_5 * __v_52; if (__v_53 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_227] = [__v_42]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_228: usize = 1; const IN_228: usize = 1; const OUT_228: usize = 24; -fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; match __v_21.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = G::from_u64(1); if (__v_31 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_32 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_33 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_34 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_35 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_36 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_37 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_38 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_39 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_40 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_228] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; match __v_21.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = G::from_u64(1); if (__v_31 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_32 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_33 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_34 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_35 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_36 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_37 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_38 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_39 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_40 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_228] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_229: usize = 3; const IN_229: usize = 3; const OUT_229: usize = 1; -fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_0), (&__v_1)) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; let __v_4: G = (__v_0 - __v_1); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_5 * __v_2); let __v_7: G = (__v_3 + __v_6); let __ret: [G; OUT_229] = [__v_7]; record.function_queries[229].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_1) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; let __v_4: G = __v_0 - __v_1; let __v_5: G = G::from_bool(__v_4 == G::ZERO); let __v_6: G = __v_5 * __v_2; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_229] = [__v_7]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_230: usize = 16; const IN_230: usize = 16; const OUT_230: usize = 1; -fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_9, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_10, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_12, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_5, __v_13, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_15, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_24]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_9, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_10, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_12, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_5, __v_13, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_15, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_24]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_231: usize = 3; const IN_231: usize = 3; const OUT_231: usize = 1; -fn aiur_fn_231(inp: [G; IN_231], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_231] = [__v_14]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = __loaded[6]; let __v_21: G = __loaded[7]; let __v_22: G = __loaded[8]; let __v_23: G = __loaded[9]; let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { _ => { let __v_25: G = G::from_u64(256); let __v_26: G = (__v_25 * __v_6); let __v_27: G = G::from_u64(65536); let __v_28: G = (__v_27 * __v_7); let __v_29: G = G::from_u64(16777216); let __v_30: G = (__v_29 * __v_8); let __v_31: G = G::from_u64(4294967296); let __v_32: G = (__v_31 * __v_9); let __v_33: G = G::from_u64(1099511627776); let __v_34: G = (__v_33 * __v_10); let __v_35: G = G::from_u64(281474976710656); let __v_36: G = (__v_35 * __v_11); let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = (__v_37 * __v_12); let __v_39: G = (__v_36 + __v_38); let __v_40: G = (__v_34 + __v_39); let __v_41: G = (__v_32 + __v_40); let __v_42: G = (__v_30 + __v_41); let __v_43: G = (__v_28 + __v_42); let __v_44: G = (__v_26 + __v_43); let __v_45: G = (__v_5 + __v_44); let __v_46: G = G::from_u64(1); let __v_47: G = (__v_45 + __v_46); let __v_48: G = G::from_u64(0); if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __v_49: G = (__v_25 * __v_17); let __v_50: G = (__v_27 * __v_18); let __v_51: G = (__v_29 * __v_19); let __v_52: G = (__v_31 * __v_20); let __v_53: G = (__v_33 * __v_21); let __v_54: G = (__v_35 * __v_22); let __v_55: G = (__v_37 * __v_23); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_52 + __v_57); let __v_59: G = (__v_51 + __v_58); let __v_60: G = (__v_50 + __v_59); let __v_61: G = (__v_49 + __v_60); let __v_62: G = (__v_16 + __v_61); if (__v_62 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, (&__args[..]))?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { (*(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228])) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __v_67: G = __r_arr[4]; let __v_68: G = __r_arr[5]; let __v_69: G = __r_arr[6]; let __v_70: G = __r_arr[7]; let __v_71: G = __r_arr[8]; let __v_72: G = __r_arr[9]; let __v_73: G = __r_arr[10]; let __v_74: G = __r_arr[11]; let __v_75: G = __r_arr[12]; let __v_76: G = __r_arr[13]; let __v_77: G = __r_arr[14]; let __v_78: G = __r_arr[15]; let __v_79: G = __r_arr[16]; let __v_80: G = __r_arr[17]; let __v_81: G = __r_arr[18]; let __v_82: G = __r_arr[19]; let __v_83: G = __r_arr[20]; let __v_84: G = __r_arr[21]; let __v_85: G = __r_arr[22]; let __v_86: G = __r_arr[23]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, (&__args[..]))?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { (*(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228])) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = __r_arr[3]; let __v_91: G = __r_arr[4]; let __v_92: G = __r_arr[5]; let __v_93: G = __r_arr[6]; let __v_94: G = __r_arr[7]; let __v_95: G = __r_arr[8]; let __v_96: G = __r_arr[9]; let __v_97: G = __r_arr[10]; let __v_98: G = __r_arr[11]; let __v_99: G = __r_arr[12]; let __v_100: G = __r_arr[13]; let __v_101: G = __r_arr[14]; let __v_102: G = __r_arr[15]; let __v_103: G = __r_arr[16]; let __v_104: G = __r_arr[17]; let __v_105: G = __r_arr[18]; let __v_106: G = __r_arr[19]; let __v_107: G = __r_arr[20]; let __v_108: G = __r_arr[21]; let __v_109: G = __r_arr[22]; let __v_110: G = __r_arr[23]; let __v_111: G = (__v_25 * __v_64); let __v_112: G = (__v_27 * __v_65); let __v_113: G = (__v_29 * __v_66); let __v_114: G = (__v_31 * __v_67); let __v_115: G = (__v_33 * __v_68); let __v_116: G = (__v_35 * __v_69); let __v_117: G = (__v_37 * __v_70); let __v_118: G = (__v_116 + __v_117); let __v_119: G = (__v_115 + __v_118); let __v_120: G = (__v_114 + __v_119); let __v_121: G = (__v_113 + __v_120); let __v_122: G = (__v_112 + __v_121); let __v_123: G = (__v_111 + __v_122); let __v_124: G = (__v_63 + __v_123); let __v_125: G = G::from_u64(16); if (__v_124 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_124.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_25 * __v_88); let __v_127: G = (__v_27 * __v_89); let __v_128: G = (__v_29 * __v_90); let __v_129: G = (__v_31 * __v_91); let __v_130: G = (__v_33 * __v_92); let __v_131: G = (__v_35 * __v_93); let __v_132: G = (__v_37 * __v_94); let __v_133: G = (__v_131 + __v_132); let __v_134: G = (__v_130 + __v_133); let __v_135: G = (__v_129 + __v_134); let __v_136: G = (__v_128 + __v_135); let __v_137: G = (__v_127 + __v_136); let __v_138: G = (__v_126 + __v_137); let __v_139: G = (__v_87 + __v_138); if (__v_139 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_140: G = (__v_25 * __v_72); let __v_141: G = (__v_27 * __v_73); let __v_142: G = (__v_29 * __v_74); let __v_143: G = (__v_31 * __v_75); let __v_144: G = (__v_33 * __v_76); let __v_145: G = (__v_35 * __v_77); let __v_146: G = (__v_37 * __v_78); let __v_147: G = (__v_145 + __v_146); let __v_148: G = (__v_144 + __v_147); let __v_149: G = (__v_143 + __v_148); let __v_150: G = (__v_142 + __v_149); let __v_151: G = (__v_141 + __v_150); let __v_152: G = (__v_140 + __v_151); let __v_153: G = (__v_71 + __v_152); let __v_154: G = (__v_25 * __v_96); let __v_155: G = (__v_27 * __v_97); let __v_156: G = (__v_29 * __v_98); let __v_157: G = (__v_31 * __v_99); let __v_158: G = (__v_33 * __v_100); let __v_159: G = (__v_35 * __v_101); let __v_160: G = (__v_37 * __v_102); let __v_161: G = (__v_159 + __v_160); let __v_162: G = (__v_158 + __v_161); let __v_163: G = (__v_157 + __v_162); let __v_164: G = (__v_156 + __v_163); let __v_165: G = (__v_155 + __v_164); let __v_166: G = (__v_154 + __v_165); let __v_167: G = (__v_95 + __v_166); if (__v_167 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_168: G = (__v_25 * __v_80); let __v_169: G = (__v_27 * __v_81); let __v_170: G = (__v_29 * __v_82); let __v_171: G = (__v_31 * __v_83); let __v_172: G = (__v_33 * __v_84); let __v_173: G = (__v_35 * __v_85); let __v_174: G = (__v_37 * __v_86); let __v_175: G = (__v_173 + __v_174); let __v_176: G = (__v_172 + __v_175); let __v_177: G = (__v_171 + __v_176); let __v_178: G = (__v_170 + __v_177); let __v_179: G = (__v_169 + __v_178); let __v_180: G = (__v_168 + __v_179); let __v_181: G = (__v_79 + __v_180); let __v_182: G = (__v_25 * __v_104); let __v_183: G = (__v_27 * __v_105); let __v_184: G = (__v_29 * __v_106); let __v_185: G = (__v_31 * __v_107); let __v_186: G = (__v_33 * __v_108); let __v_187: G = (__v_35 * __v_109); let __v_188: G = (__v_37 * __v_110); let __v_189: G = (__v_187 + __v_188); let __v_190: G = (__v_186 + __v_189); let __v_191: G = (__v_185 + __v_190); let __v_192: G = (__v_184 + __v_191); let __v_193: G = (__v_183 + __v_192); let __v_194: G = (__v_182 + __v_193); let __v_195: G = (__v_103 + __v_194); let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_196: G = G::from_u8(__gb[0]); let __v_197: G = G::from_u8(__gb[1]); let __v_198: G = G::from_u8(__gb[2]); let __v_199: G = G::from_u8(__gb[3]); let __v_200: G = G::from_u8(__gb[4]); let __v_201: G = G::from_u8(__gb[5]); let __v_202: G = G::from_u8(__gb[6]); let __v_203: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_200; let __vj = __v_201; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_202; let __vj = __v_203; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_204: G = (__v_25 * __v_197); let __v_205: G = (__v_27 * __v_198); let __v_206: G = (__v_29 * __v_199); let __v_207: G = (__v_31 * __v_200); let __v_208: G = (__v_33 * __v_201); let __v_209: G = (__v_35 * __v_202); let __v_210: G = (__v_37 * __v_203); let __v_211: G = (__v_209 + __v_210); let __v_212: G = (__v_208 + __v_211); let __v_213: G = (__v_207 + __v_212); let __v_214: G = (__v_206 + __v_213); let __v_215: G = (__v_205 + __v_214); let __v_216: G = (__v_204 + __v_215); let __v_217: G = (__v_196 + __v_216); if (__v_217 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_218: G = G::from_u64(1020); let __v_219: G = (__v_203 - __v_218); let __v_220: G = (__v_202 + __v_219); let __v_221: G = (__v_201 + __v_220); let __v_222: G = (__v_200 + __v_221); let __v_223: G = G::from_bool((__v_222 == G::ZERO)); let __v_224: G = (__v_198 + __v_199); let __v_225: G = (__v_197 + __v_224); let __v_226: G = (__v_196 + __v_225); let __v_227: G = G::from_bool((__v_226 == G::ZERO)); let __v_228: G = (__v_46 - __v_227); let __v_229: G = (__v_223 * __v_228); let __v_230: G = (__v_46 - __v_229); if (__v_230 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_195.as_canonical_u64().to_le_bytes(); let __v_231: G = G::from_u8(__gb[0]); let __v_232: G = G::from_u8(__gb[1]); let __v_233: G = G::from_u8(__gb[2]); let __v_234: G = G::from_u8(__gb[3]); let __v_235: G = G::from_u8(__gb[4]); let __v_236: G = G::from_u8(__gb[5]); let __v_237: G = G::from_u8(__gb[6]); let __v_238: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_235; let __vj = __v_236; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_239: G = (__v_25 * __v_232); let __v_240: G = (__v_27 * __v_233); let __v_241: G = (__v_29 * __v_234); let __v_242: G = (__v_31 * __v_235); let __v_243: G = (__v_33 * __v_236); let __v_244: G = (__v_35 * __v_237); let __v_245: G = (__v_37 * __v_238); let __v_246: G = (__v_244 + __v_245); let __v_247: G = (__v_243 + __v_246); let __v_248: G = (__v_242 + __v_247); let __v_249: G = (__v_241 + __v_248); let __v_250: G = (__v_240 + __v_249); let __v_251: G = (__v_239 + __v_250); let __v_252: G = (__v_231 + __v_251); if (__v_252 != __v_195) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_195.as_canonical_u64(), msg: None }); } let __v_253: G = (__v_238 - __v_218); let __v_254: G = (__v_237 + __v_253); let __v_255: G = (__v_236 + __v_254); let __v_256: G = (__v_235 + __v_255); let __v_257: G = G::from_bool((__v_256 == G::ZERO)); let __v_258: G = (__v_233 + __v_234); let __v_259: G = (__v_232 + __v_258); let __v_260: G = (__v_231 + __v_259); let __v_261: G = G::from_bool((__v_260 == G::ZERO)); let __v_262: G = (__v_46 - __v_261); let __v_263: G = (__v_257 * __v_262); let __v_264: G = (__v_46 - __v_263); if (__v_264 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_265: G = __r_arr[0]; if (__v_265 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_265.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_266: G = (__v_153 - __v_1); let __v_267: G = G::from_bool((__v_266 == G::ZERO)); let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_268: G = G::from_u8(__gb[0]); let __v_269: G = G::from_u8(__gb[1]); let __v_270: G = G::from_u8(__gb[2]); let __v_271: G = G::from_u8(__gb[3]); let __v_272: G = G::from_u8(__gb[4]); let __v_273: G = G::from_u8(__gb[5]); let __v_274: G = G::from_u8(__gb[6]); let __v_275: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_272; let __vj = __v_273; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_274; let __vj = __v_275; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_276: G = (__v_25 * __v_269); let __v_277: G = (__v_27 * __v_270); let __v_278: G = (__v_29 * __v_271); let __v_279: G = (__v_31 * __v_272); let __v_280: G = (__v_33 * __v_273); let __v_281: G = (__v_35 * __v_274); let __v_282: G = (__v_37 * __v_275); let __v_283: G = (__v_281 + __v_282); let __v_284: G = (__v_280 + __v_283); let __v_285: G = (__v_279 + __v_284); let __v_286: G = (__v_278 + __v_285); let __v_287: G = (__v_277 + __v_286); let __v_288: G = (__v_276 + __v_287); let __v_289: G = (__v_268 + __v_288); if (__v_289 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_289.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_290: G = (__v_275 - __v_218); let __v_291: G = (__v_274 + __v_290); let __v_292: G = (__v_273 + __v_291); let __v_293: G = (__v_272 + __v_292); let __v_294: G = G::from_bool((__v_293 == G::ZERO)); let __v_295: G = (__v_270 + __v_271); let __v_296: G = (__v_269 + __v_295); let __v_297: G = (__v_268 + __v_296); let __v_298: G = G::from_bool((__v_297 == G::ZERO)); let __v_299: G = (__v_46 - __v_298); let __v_300: G = (__v_294 * __v_299); let __v_301: G = (__v_46 - __v_300); if (__v_301 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_301.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_302: G = G::from_u8(__gb[0]); let __v_303: G = G::from_u8(__gb[1]); let __v_304: G = G::from_u8(__gb[2]); let __v_305: G = G::from_u8(__gb[3]); let __v_306: G = G::from_u8(__gb[4]); let __v_307: G = G::from_u8(__gb[5]); let __v_308: G = G::from_u8(__gb[6]); let __v_309: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_304; let __vj = __v_305; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_306; let __vj = __v_307; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_308; let __vj = __v_309; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_310: G = (__v_25 * __v_303); let __v_311: G = (__v_27 * __v_304); let __v_312: G = (__v_29 * __v_305); let __v_313: G = (__v_31 * __v_306); let __v_314: G = (__v_33 * __v_307); let __v_315: G = (__v_35 * __v_308); let __v_316: G = (__v_37 * __v_309); let __v_317: G = (__v_315 + __v_316); let __v_318: G = (__v_314 + __v_317); let __v_319: G = (__v_313 + __v_318); let __v_320: G = (__v_312 + __v_319); let __v_321: G = (__v_311 + __v_320); let __v_322: G = (__v_310 + __v_321); let __v_323: G = (__v_302 + __v_322); if (__v_323 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_323.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_324: G = (__v_309 - __v_218); let __v_325: G = (__v_308 + __v_324); let __v_326: G = (__v_307 + __v_325); let __v_327: G = (__v_306 + __v_326); let __v_328: G = G::from_bool((__v_327 == G::ZERO)); let __v_329: G = (__v_304 + __v_305); let __v_330: G = (__v_303 + __v_329); let __v_331: G = (__v_302 + __v_330); let __v_332: G = G::from_bool((__v_331 == G::ZERO)); let __v_333: G = (__v_46 - __v_332); let __v_334: G = (__v_328 * __v_333); let __v_335: G = (__v_46 - __v_334); if (__v_335 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_336: G = __r_arr[0]; let __v_337: G = (__v_46 - __v_336); let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_338: G = G::from_u8(__gb[0]); let __v_339: G = G::from_u8(__gb[1]); let __v_340: G = G::from_u8(__gb[2]); let __v_341: G = G::from_u8(__gb[3]); let __v_342: G = G::from_u8(__gb[4]); let __v_343: G = G::from_u8(__gb[5]); let __v_344: G = G::from_u8(__gb[6]); let __v_345: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_338; let __vj = __v_339; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_340; let __vj = __v_341; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_342; let __vj = __v_343; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_344; let __vj = __v_345; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_346: G = (__v_25 * __v_339); let __v_347: G = (__v_27 * __v_340); let __v_348: G = (__v_29 * __v_341); let __v_349: G = (__v_31 * __v_342); let __v_350: G = (__v_33 * __v_343); let __v_351: G = (__v_35 * __v_344); let __v_352: G = (__v_37 * __v_345); let __v_353: G = (__v_351 + __v_352); let __v_354: G = (__v_350 + __v_353); let __v_355: G = (__v_349 + __v_354); let __v_356: G = (__v_348 + __v_355); let __v_357: G = (__v_347 + __v_356); let __v_358: G = (__v_346 + __v_357); let __v_359: G = (__v_338 + __v_358); if (__v_359 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_360: G = (__v_345 - __v_218); let __v_361: G = (__v_344 + __v_360); let __v_362: G = (__v_343 + __v_361); let __v_363: G = (__v_342 + __v_362); let __v_364: G = G::from_bool((__v_363 == G::ZERO)); let __v_365: G = (__v_340 + __v_341); let __v_366: G = (__v_339 + __v_365); let __v_367: G = (__v_338 + __v_366); let __v_368: G = G::from_bool((__v_367 == G::ZERO)); let __v_369: G = (__v_46 - __v_368); let __v_370: G = (__v_364 * __v_369); let __v_371: G = (__v_46 - __v_370); if (__v_371 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_372: G = G::from_u8(__gb[0]); let __v_373: G = G::from_u8(__gb[1]); let __v_374: G = G::from_u8(__gb[2]); let __v_375: G = G::from_u8(__gb[3]); let __v_376: G = G::from_u8(__gb[4]); let __v_377: G = G::from_u8(__gb[5]); let __v_378: G = G::from_u8(__gb[6]); let __v_379: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_372; let __vj = __v_373; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_374; let __vj = __v_375; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_376; let __vj = __v_377; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_378; let __vj = __v_379; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_380: G = (__v_25 * __v_373); let __v_381: G = (__v_27 * __v_374); let __v_382: G = (__v_29 * __v_375); let __v_383: G = (__v_31 * __v_376); let __v_384: G = (__v_33 * __v_377); let __v_385: G = (__v_35 * __v_378); let __v_386: G = (__v_37 * __v_379); let __v_387: G = (__v_385 + __v_386); let __v_388: G = (__v_384 + __v_387); let __v_389: G = (__v_383 + __v_388); let __v_390: G = (__v_382 + __v_389); let __v_391: G = (__v_381 + __v_390); let __v_392: G = (__v_380 + __v_391); let __v_393: G = (__v_372 + __v_392); if (__v_393 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_393.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_394: G = (__v_379 - __v_218); let __v_395: G = (__v_378 + __v_394); let __v_396: G = (__v_377 + __v_395); let __v_397: G = (__v_376 + __v_396); let __v_398: G = G::from_bool((__v_397 == G::ZERO)); let __v_399: G = (__v_374 + __v_375); let __v_400: G = (__v_373 + __v_399); let __v_401: G = (__v_372 + __v_400); let __v_402: G = G::from_bool((__v_401 == G::ZERO)); let __v_403: G = (__v_46 - __v_402); let __v_404: G = (__v_398 * __v_403); let __v_405: G = (__v_46 - __v_404); if (__v_405 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_406: G = __r_arr[0]; let __v_407: G = (__v_267 * __v_406); let __v_408: G = (__v_337 + __v_407); if (__v_408 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, (&__args[..]))?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { (*(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231])) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_409]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_231(inp: [G; IN_231], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_231] = [__v_14]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = __loaded[6]; let __v_21: G = __loaded[7]; let __v_22: G = __loaded[8]; let __v_23: G = __loaded[9]; let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { _ => { let __v_25: G = G::from_u64(256); let __v_26: G = __v_25 * __v_6; let __v_27: G = G::from_u64(65536); let __v_28: G = __v_27 * __v_7; let __v_29: G = G::from_u64(16777216); let __v_30: G = __v_29 * __v_8; let __v_31: G = G::from_u64(4294967296); let __v_32: G = __v_31 * __v_9; let __v_33: G = G::from_u64(1099511627776); let __v_34: G = __v_33 * __v_10; let __v_35: G = G::from_u64(281474976710656); let __v_36: G = __v_35 * __v_11; let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = __v_37 * __v_12; let __v_39: G = __v_36 + __v_38; let __v_40: G = __v_34 + __v_39; let __v_41: G = __v_32 + __v_40; let __v_42: G = __v_30 + __v_41; let __v_43: G = __v_28 + __v_42; let __v_44: G = __v_26 + __v_43; let __v_45: G = __v_5 + __v_44; let __v_46: G = G::from_u64(1); let __v_47: G = __v_45 + __v_46; let __v_48: G = G::from_u64(0); if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __v_49: G = __v_25 * __v_17; let __v_50: G = __v_27 * __v_18; let __v_51: G = __v_29 * __v_19; let __v_52: G = __v_31 * __v_20; let __v_53: G = __v_33 * __v_21; let __v_54: G = __v_35 * __v_22; let __v_55: G = __v_37 * __v_23; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_53 + __v_56; let __v_58: G = __v_52 + __v_57; let __v_59: G = __v_51 + __v_58; let __v_60: G = __v_50 + __v_59; let __v_61: G = __v_49 + __v_60; let __v_62: G = __v_16 + __v_61; if (__v_62 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, &__args[..])?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __v_67: G = __r_arr[4]; let __v_68: G = __r_arr[5]; let __v_69: G = __r_arr[6]; let __v_70: G = __r_arr[7]; let __v_71: G = __r_arr[8]; let __v_72: G = __r_arr[9]; let __v_73: G = __r_arr[10]; let __v_74: G = __r_arr[11]; let __v_75: G = __r_arr[12]; let __v_76: G = __r_arr[13]; let __v_77: G = __r_arr[14]; let __v_78: G = __r_arr[15]; let __v_79: G = __r_arr[16]; let __v_80: G = __r_arr[17]; let __v_81: G = __r_arr[18]; let __v_82: G = __r_arr[19]; let __v_83: G = __r_arr[20]; let __v_84: G = __r_arr[21]; let __v_85: G = __r_arr[22]; let __v_86: G = __r_arr[23]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, &__args[..])?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = __r_arr[3]; let __v_91: G = __r_arr[4]; let __v_92: G = __r_arr[5]; let __v_93: G = __r_arr[6]; let __v_94: G = __r_arr[7]; let __v_95: G = __r_arr[8]; let __v_96: G = __r_arr[9]; let __v_97: G = __r_arr[10]; let __v_98: G = __r_arr[11]; let __v_99: G = __r_arr[12]; let __v_100: G = __r_arr[13]; let __v_101: G = __r_arr[14]; let __v_102: G = __r_arr[15]; let __v_103: G = __r_arr[16]; let __v_104: G = __r_arr[17]; let __v_105: G = __r_arr[18]; let __v_106: G = __r_arr[19]; let __v_107: G = __r_arr[20]; let __v_108: G = __r_arr[21]; let __v_109: G = __r_arr[22]; let __v_110: G = __r_arr[23]; let __v_111: G = __v_25 * __v_64; let __v_112: G = __v_27 * __v_65; let __v_113: G = __v_29 * __v_66; let __v_114: G = __v_31 * __v_67; let __v_115: G = __v_33 * __v_68; let __v_116: G = __v_35 * __v_69; let __v_117: G = __v_37 * __v_70; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_115 + __v_118; let __v_120: G = __v_114 + __v_119; let __v_121: G = __v_113 + __v_120; let __v_122: G = __v_112 + __v_121; let __v_123: G = __v_111 + __v_122; let __v_124: G = __v_63 + __v_123; let __v_125: G = G::from_u64(16); if (__v_124 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_124.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_126: G = __v_25 * __v_88; let __v_127: G = __v_27 * __v_89; let __v_128: G = __v_29 * __v_90; let __v_129: G = __v_31 * __v_91; let __v_130: G = __v_33 * __v_92; let __v_131: G = __v_35 * __v_93; let __v_132: G = __v_37 * __v_94; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_130 + __v_133; let __v_135: G = __v_129 + __v_134; let __v_136: G = __v_128 + __v_135; let __v_137: G = __v_127 + __v_136; let __v_138: G = __v_126 + __v_137; let __v_139: G = __v_87 + __v_138; if (__v_139 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_140: G = __v_25 * __v_72; let __v_141: G = __v_27 * __v_73; let __v_142: G = __v_29 * __v_74; let __v_143: G = __v_31 * __v_75; let __v_144: G = __v_33 * __v_76; let __v_145: G = __v_35 * __v_77; let __v_146: G = __v_37 * __v_78; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_144 + __v_147; let __v_149: G = __v_143 + __v_148; let __v_150: G = __v_142 + __v_149; let __v_151: G = __v_141 + __v_150; let __v_152: G = __v_140 + __v_151; let __v_153: G = __v_71 + __v_152; let __v_154: G = __v_25 * __v_96; let __v_155: G = __v_27 * __v_97; let __v_156: G = __v_29 * __v_98; let __v_157: G = __v_31 * __v_99; let __v_158: G = __v_33 * __v_100; let __v_159: G = __v_35 * __v_101; let __v_160: G = __v_37 * __v_102; let __v_161: G = __v_159 + __v_160; let __v_162: G = __v_158 + __v_161; let __v_163: G = __v_157 + __v_162; let __v_164: G = __v_156 + __v_163; let __v_165: G = __v_155 + __v_164; let __v_166: G = __v_154 + __v_165; let __v_167: G = __v_95 + __v_166; if (__v_167 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_168: G = __v_25 * __v_80; let __v_169: G = __v_27 * __v_81; let __v_170: G = __v_29 * __v_82; let __v_171: G = __v_31 * __v_83; let __v_172: G = __v_33 * __v_84; let __v_173: G = __v_35 * __v_85; let __v_174: G = __v_37 * __v_86; let __v_175: G = __v_173 + __v_174; let __v_176: G = __v_172 + __v_175; let __v_177: G = __v_171 + __v_176; let __v_178: G = __v_170 + __v_177; let __v_179: G = __v_169 + __v_178; let __v_180: G = __v_168 + __v_179; let __v_181: G = __v_79 + __v_180; let __v_182: G = __v_25 * __v_104; let __v_183: G = __v_27 * __v_105; let __v_184: G = __v_29 * __v_106; let __v_185: G = __v_31 * __v_107; let __v_186: G = __v_33 * __v_108; let __v_187: G = __v_35 * __v_109; let __v_188: G = __v_37 * __v_110; let __v_189: G = __v_187 + __v_188; let __v_190: G = __v_186 + __v_189; let __v_191: G = __v_185 + __v_190; let __v_192: G = __v_184 + __v_191; let __v_193: G = __v_183 + __v_192; let __v_194: G = __v_182 + __v_193; let __v_195: G = __v_103 + __v_194; let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_196: G = G::from_u8(__gb[0]); let __v_197: G = G::from_u8(__gb[1]); let __v_198: G = G::from_u8(__gb[2]); let __v_199: G = G::from_u8(__gb[3]); let __v_200: G = G::from_u8(__gb[4]); let __v_201: G = G::from_u8(__gb[5]); let __v_202: G = G::from_u8(__gb[6]); let __v_203: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_200; let __vj = __v_201; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_202; let __vj = __v_203; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_204: G = __v_25 * __v_197; let __v_205: G = __v_27 * __v_198; let __v_206: G = __v_29 * __v_199; let __v_207: G = __v_31 * __v_200; let __v_208: G = __v_33 * __v_201; let __v_209: G = __v_35 * __v_202; let __v_210: G = __v_37 * __v_203; let __v_211: G = __v_209 + __v_210; let __v_212: G = __v_208 + __v_211; let __v_213: G = __v_207 + __v_212; let __v_214: G = __v_206 + __v_213; let __v_215: G = __v_205 + __v_214; let __v_216: G = __v_204 + __v_215; let __v_217: G = __v_196 + __v_216; if (__v_217 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_218: G = G::from_u64(1020); let __v_219: G = __v_203 - __v_218; let __v_220: G = __v_202 + __v_219; let __v_221: G = __v_201 + __v_220; let __v_222: G = __v_200 + __v_221; let __v_223: G = G::from_bool(__v_222 == G::ZERO); let __v_224: G = __v_198 + __v_199; let __v_225: G = __v_197 + __v_224; let __v_226: G = __v_196 + __v_225; let __v_227: G = G::from_bool(__v_226 == G::ZERO); let __v_228: G = __v_46 - __v_227; let __v_229: G = __v_223 * __v_228; let __v_230: G = __v_46 - __v_229; if (__v_230 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_195.as_canonical_u64().to_le_bytes(); let __v_231: G = G::from_u8(__gb[0]); let __v_232: G = G::from_u8(__gb[1]); let __v_233: G = G::from_u8(__gb[2]); let __v_234: G = G::from_u8(__gb[3]); let __v_235: G = G::from_u8(__gb[4]); let __v_236: G = G::from_u8(__gb[5]); let __v_237: G = G::from_u8(__gb[6]); let __v_238: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_235; let __vj = __v_236; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_239: G = __v_25 * __v_232; let __v_240: G = __v_27 * __v_233; let __v_241: G = __v_29 * __v_234; let __v_242: G = __v_31 * __v_235; let __v_243: G = __v_33 * __v_236; let __v_244: G = __v_35 * __v_237; let __v_245: G = __v_37 * __v_238; let __v_246: G = __v_244 + __v_245; let __v_247: G = __v_243 + __v_246; let __v_248: G = __v_242 + __v_247; let __v_249: G = __v_241 + __v_248; let __v_250: G = __v_240 + __v_249; let __v_251: G = __v_239 + __v_250; let __v_252: G = __v_231 + __v_251; if (__v_252 != __v_195) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_195.as_canonical_u64(), msg: None }); } let __v_253: G = __v_238 - __v_218; let __v_254: G = __v_237 + __v_253; let __v_255: G = __v_236 + __v_254; let __v_256: G = __v_235 + __v_255; let __v_257: G = G::from_bool(__v_256 == G::ZERO); let __v_258: G = __v_233 + __v_234; let __v_259: G = __v_232 + __v_258; let __v_260: G = __v_231 + __v_259; let __v_261: G = G::from_bool(__v_260 == G::ZERO); let __v_262: G = __v_46 - __v_261; let __v_263: G = __v_257 * __v_262; let __v_264: G = __v_46 - __v_263; if (__v_264 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_265: G = __r_arr[0]; if (__v_265 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_265.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_266: G = __v_153 - __v_1; let __v_267: G = G::from_bool(__v_266 == G::ZERO); let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_268: G = G::from_u8(__gb[0]); let __v_269: G = G::from_u8(__gb[1]); let __v_270: G = G::from_u8(__gb[2]); let __v_271: G = G::from_u8(__gb[3]); let __v_272: G = G::from_u8(__gb[4]); let __v_273: G = G::from_u8(__gb[5]); let __v_274: G = G::from_u8(__gb[6]); let __v_275: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_272; let __vj = __v_273; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_274; let __vj = __v_275; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_276: G = __v_25 * __v_269; let __v_277: G = __v_27 * __v_270; let __v_278: G = __v_29 * __v_271; let __v_279: G = __v_31 * __v_272; let __v_280: G = __v_33 * __v_273; let __v_281: G = __v_35 * __v_274; let __v_282: G = __v_37 * __v_275; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_280 + __v_283; let __v_285: G = __v_279 + __v_284; let __v_286: G = __v_278 + __v_285; let __v_287: G = __v_277 + __v_286; let __v_288: G = __v_276 + __v_287; let __v_289: G = __v_268 + __v_288; if (__v_289 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_289.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_290: G = __v_275 - __v_218; let __v_291: G = __v_274 + __v_290; let __v_292: G = __v_273 + __v_291; let __v_293: G = __v_272 + __v_292; let __v_294: G = G::from_bool(__v_293 == G::ZERO); let __v_295: G = __v_270 + __v_271; let __v_296: G = __v_269 + __v_295; let __v_297: G = __v_268 + __v_296; let __v_298: G = G::from_bool(__v_297 == G::ZERO); let __v_299: G = __v_46 - __v_298; let __v_300: G = __v_294 * __v_299; let __v_301: G = __v_46 - __v_300; if (__v_301 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_301.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_302: G = G::from_u8(__gb[0]); let __v_303: G = G::from_u8(__gb[1]); let __v_304: G = G::from_u8(__gb[2]); let __v_305: G = G::from_u8(__gb[3]); let __v_306: G = G::from_u8(__gb[4]); let __v_307: G = G::from_u8(__gb[5]); let __v_308: G = G::from_u8(__gb[6]); let __v_309: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_304; let __vj = __v_305; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_306; let __vj = __v_307; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_308; let __vj = __v_309; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_310: G = __v_25 * __v_303; let __v_311: G = __v_27 * __v_304; let __v_312: G = __v_29 * __v_305; let __v_313: G = __v_31 * __v_306; let __v_314: G = __v_33 * __v_307; let __v_315: G = __v_35 * __v_308; let __v_316: G = __v_37 * __v_309; let __v_317: G = __v_315 + __v_316; let __v_318: G = __v_314 + __v_317; let __v_319: G = __v_313 + __v_318; let __v_320: G = __v_312 + __v_319; let __v_321: G = __v_311 + __v_320; let __v_322: G = __v_310 + __v_321; let __v_323: G = __v_302 + __v_322; if (__v_323 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_323.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_324: G = __v_309 - __v_218; let __v_325: G = __v_308 + __v_324; let __v_326: G = __v_307 + __v_325; let __v_327: G = __v_306 + __v_326; let __v_328: G = G::from_bool(__v_327 == G::ZERO); let __v_329: G = __v_304 + __v_305; let __v_330: G = __v_303 + __v_329; let __v_331: G = __v_302 + __v_330; let __v_332: G = G::from_bool(__v_331 == G::ZERO); let __v_333: G = __v_46 - __v_332; let __v_334: G = __v_328 * __v_333; let __v_335: G = __v_46 - __v_334; if (__v_335 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_336: G = __r_arr[0]; let __v_337: G = __v_46 - __v_336; let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_338: G = G::from_u8(__gb[0]); let __v_339: G = G::from_u8(__gb[1]); let __v_340: G = G::from_u8(__gb[2]); let __v_341: G = G::from_u8(__gb[3]); let __v_342: G = G::from_u8(__gb[4]); let __v_343: G = G::from_u8(__gb[5]); let __v_344: G = G::from_u8(__gb[6]); let __v_345: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_338; let __vj = __v_339; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_340; let __vj = __v_341; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_342; let __vj = __v_343; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_344; let __vj = __v_345; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_346: G = __v_25 * __v_339; let __v_347: G = __v_27 * __v_340; let __v_348: G = __v_29 * __v_341; let __v_349: G = __v_31 * __v_342; let __v_350: G = __v_33 * __v_343; let __v_351: G = __v_35 * __v_344; let __v_352: G = __v_37 * __v_345; let __v_353: G = __v_351 + __v_352; let __v_354: G = __v_350 + __v_353; let __v_355: G = __v_349 + __v_354; let __v_356: G = __v_348 + __v_355; let __v_357: G = __v_347 + __v_356; let __v_358: G = __v_346 + __v_357; let __v_359: G = __v_338 + __v_358; if (__v_359 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_360: G = __v_345 - __v_218; let __v_361: G = __v_344 + __v_360; let __v_362: G = __v_343 + __v_361; let __v_363: G = __v_342 + __v_362; let __v_364: G = G::from_bool(__v_363 == G::ZERO); let __v_365: G = __v_340 + __v_341; let __v_366: G = __v_339 + __v_365; let __v_367: G = __v_338 + __v_366; let __v_368: G = G::from_bool(__v_367 == G::ZERO); let __v_369: G = __v_46 - __v_368; let __v_370: G = __v_364 * __v_369; let __v_371: G = __v_46 - __v_370; if (__v_371 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_372: G = G::from_u8(__gb[0]); let __v_373: G = G::from_u8(__gb[1]); let __v_374: G = G::from_u8(__gb[2]); let __v_375: G = G::from_u8(__gb[3]); let __v_376: G = G::from_u8(__gb[4]); let __v_377: G = G::from_u8(__gb[5]); let __v_378: G = G::from_u8(__gb[6]); let __v_379: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_372; let __vj = __v_373; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_374; let __vj = __v_375; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_376; let __vj = __v_377; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_378; let __vj = __v_379; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_380: G = __v_25 * __v_373; let __v_381: G = __v_27 * __v_374; let __v_382: G = __v_29 * __v_375; let __v_383: G = __v_31 * __v_376; let __v_384: G = __v_33 * __v_377; let __v_385: G = __v_35 * __v_378; let __v_386: G = __v_37 * __v_379; let __v_387: G = __v_385 + __v_386; let __v_388: G = __v_384 + __v_387; let __v_389: G = __v_383 + __v_388; let __v_390: G = __v_382 + __v_389; let __v_391: G = __v_381 + __v_390; let __v_392: G = __v_380 + __v_391; let __v_393: G = __v_372 + __v_392; if (__v_393 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_393.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_394: G = __v_379 - __v_218; let __v_395: G = __v_378 + __v_394; let __v_396: G = __v_377 + __v_395; let __v_397: G = __v_376 + __v_396; let __v_398: G = G::from_bool(__v_397 == G::ZERO); let __v_399: G = __v_374 + __v_375; let __v_400: G = __v_373 + __v_399; let __v_401: G = __v_372 + __v_400; let __v_402: G = G::from_bool(__v_401 == G::ZERO); let __v_403: G = __v_46 - __v_402; let __v_404: G = __v_398 * __v_403; let __v_405: G = __v_46 - __v_404; if (__v_405 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_406: G = __r_arr[0]; let __v_407: G = __v_267 * __v_406; let __v_408: G = __v_337 + __v_407; if (__v_408 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, &__args[..])?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_409]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_232: usize = 46; const IN_232: usize = 46; const OUT_232: usize = 2; -fn aiur_fn_232(inp: [G; IN_232], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { let __v_46: G = G::from_u64(0); if (__v_1 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } if (__v_2 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_47: G = G::from_u64(1); if (__v_3 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None }); } match __v_12.as_canonical_u64() { _ => { match __v_17.as_canonical_u64() { _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_21]; 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_48: G = __r_arr[0]; let __v_49: G = G::from_bool((__v_48 == G::ZERO)); let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_39]; 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_51: G = __r_arr[0]; if (__v_51 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_40]; 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_52: G = __r_arr[0]; if (__v_52 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_36]; 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_53: G = __r_arr[0]; if (__v_53 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_17]; 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_56: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, (&__args[..]))?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { (*(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302])) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = (__v_56 - __v_57); let __v_59: G = G::from_bool((__v_58 == G::ZERO)); if (__v_59 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, (&__args[..]))?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { (*(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207])) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_11, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_60]; 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_62: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_21]; 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_63: G = __r_arr[0]; let __v_64: G = (__v_62 - __v_63); let __v_65: G = G::from_bool((__v_64 == G::ZERO)); if (__v_65 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = G::from_u64(1); if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_13, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, (&__args[..]))?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { (*(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221])) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; if (__v_68 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; if (__v_69 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, (&__args[..]))?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { (*(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225])) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_22]; 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_72: G = __r_arr[0]; if (__v_71 != __v_72) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None }); } let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_73, __v_73, __v_73]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_74]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_41, __v_16, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = G::from_u64(0); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_60, __v_61, __v_22, __v_21, __v_39, __v_40, __v_37, __v_38, __v_36, __v_79, __v_80, __v_81, __v_42, __v_43, __v_44, __v_45, __v_74, __v_75, __v_76, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, (&__args[..]))?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { (*(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203])) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_60]; 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_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_23]; 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_84: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_24]; 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_85: G = __r_arr[0]; let __v_86: G = (__v_85 - __v_84); let __v_87: G = G::from_bool((__v_86 == G::ZERO)); let __v_88: G = G::from_u64(1); if (__v_87 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_25]; 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_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = (__v_90 + __v_91); if (__v_89 != __v_92) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_26]; 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_93: G = __r_arr[0]; let __v_94: G = (__v_93 - __v_84); let __v_95: G = G::from_bool((__v_94 == G::ZERO)); if (__v_95 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_27]; 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_96: G = __r_arr[0]; if (__v_96 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __v_97: G = { let __values: [G; 3] = [__v_88, __v_88, __v_88]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_37.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_97]; }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_38, __v_97]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; break '__mc_1 [__v_98]; }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }; let __v_98: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_36, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_40, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_39, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_78, __v_101]; 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_102: G = __r_arr[0]; let __v_103: G = G::from_u64(1); let __v_104: G = { let __values: [G; 3] = [__v_103, __v_103, __v_103]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_102, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; let __v_108: G = __r_arr[3]; let __v_109: G = __r_arr[4]; let __v_110: G = __r_arr[5]; let __v_111: G = __r_arr[6]; let __v_112: G = __r_arr[7]; let __v_113: G = __r_arr[8]; let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = __r_arr[12]; let __v_118: G = __r_arr[13]; let __v_119: G = __r_arr[14]; let __v_120: G = __r_arr[15]; let __v_121: G = __r_arr[16]; let __v_122: G = __r_arr[17]; let __v_123: G = G::from_u64(256); let __v_124: G = (__v_123 * __v_106); let __v_125: G = G::from_u64(65536); let __v_126: G = (__v_125 * __v_107); let __v_127: G = G::from_u64(16777216); let __v_128: G = (__v_127 * __v_108); let __v_129: G = G::from_u64(4294967296); let __v_130: G = (__v_129 * __v_109); let __v_131: G = G::from_u64(1099511627776); let __v_132: G = (__v_131 * __v_110); let __v_133: G = G::from_u64(281474976710656); let __v_134: G = (__v_133 * __v_111); let __v_135: G = G::from_u64(72057594037927936); let __v_136: G = (__v_135 * __v_112); let __v_137: G = (__v_134 + __v_136); let __v_138: G = (__v_132 + __v_137); let __v_139: G = (__v_130 + __v_138); let __v_140: G = (__v_128 + __v_139); let __v_141: G = (__v_126 + __v_140); let __v_142: G = (__v_124 + __v_141); let __v_143: G = (__v_105 + __v_142); let __v_144: G = (__v_123 * __v_114); let __v_145: G = (__v_125 * __v_115); let __v_146: G = (__v_127 * __v_116); let __v_147: G = (__v_129 * __v_117); let __v_148: G = (__v_131 * __v_118); let __v_149: G = (__v_133 * __v_119); let __v_150: G = (__v_135 * __v_120); let __v_151: G = (__v_149 + __v_150); let __v_152: G = (__v_148 + __v_151); let __v_153: G = (__v_147 + __v_152); let __v_154: G = (__v_146 + __v_153); let __v_155: G = (__v_145 + __v_154); let __v_156: G = (__v_144 + __v_155); let __v_157: G = (__v_113 + __v_156); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_121, __v_23, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, (&__args[..]))?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { (*(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134])) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_159, __v_160]; 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_161: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_161, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_162, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = (__v_84 + __v_0); let __v_166: G = G::from_u64(33); let __v_167: G = { let __a_val = __v_165.as_canonical_u64(); let __b_val = __v_166.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; if (__v_167 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_163, __v_164, __v_4, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_25, __v_168, __v_18, __v_19, __v_20, __v_73, __v_37, __v_38, __v_61, __v_22, __v_83, __v_0, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; if (__v_169 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_163, __v_164, __v_171, __v_143, __v_157, __v_39, __v_40, __v_36, __v_37, __v_38, __v_18, __v_19, __v_20, __v_73, __v_61, __v_22, __v_76, __v_77, __v_83, __v_0, __v_165, __v_158, __v_23, __v_27, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_173: G = __r_arr[0]; if (__v_173 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, (&__args[..]))?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { (*(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222])) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_232] = [__v_174, __v_175]; record.function_queries[232].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } +fn aiur_fn_232(inp: [G; IN_232], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { let __v_46: G = G::from_u64(0); if (__v_1 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } if (__v_2 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_47: G = G::from_u64(1); if (__v_3 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None }); } match __v_12.as_canonical_u64() { _ => { match __v_17.as_canonical_u64() { _ => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_21]; 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_48: G = __r_arr[0]; let __v_49: G = G::from_bool(__v_48 == G::ZERO); let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_39]; 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_51: G = __r_arr[0]; if (__v_51 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_40]; 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_52: G = __r_arr[0]; if (__v_52 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_36]; 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_53: G = __r_arr[0]; if (__v_53 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_17]; 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_56: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __v_56 - __v_57; let __v_59: G = G::from_bool(__v_58 == G::ZERO); if (__v_59 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, &__args[..])?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_11, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_60]; 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_62: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_21]; 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_63: G = __r_arr[0]; let __v_64: G = __v_62 - __v_63; let __v_65: G = G::from_bool(__v_64 == G::ZERO); if (__v_65 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = G::from_u64(1); if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_13, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, &__args[..])?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; if (__v_68 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; if (__v_69 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, &__args[..])?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_22]; 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_72: G = __r_arr[0]; if (__v_71 != __v_72) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None }); } let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_73, __v_73, __v_73]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_74]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_41, __v_16, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = G::from_u64(0); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_60, __v_61, __v_22, __v_21, __v_39, __v_40, __v_37, __v_38, __v_36, __v_79, __v_80, __v_81, __v_42, __v_43, __v_44, __v_45, __v_74, __v_75, __v_76, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, &__args[..])?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_60]; 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_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_23]; 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_84: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_24]; 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_85: G = __r_arr[0]; let __v_86: G = __v_85 - __v_84; let __v_87: G = G::from_bool(__v_86 == G::ZERO); let __v_88: G = G::from_u64(1); if (__v_87 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_25]; 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_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __v_90 + __v_91; if (__v_89 != __v_92) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_26]; 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_93: G = __r_arr[0]; let __v_94: G = __v_93 - __v_84; let __v_95: G = G::from_bool(__v_94 == G::ZERO); if (__v_95 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_27]; 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_96: G = __r_arr[0]; if (__v_96 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __v_97: G = { let __values: [G; 3] = [__v_88, __v_88, __v_88]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_37.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_97]; }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_38, __v_97]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; break '__mc_1 [__v_98]; }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }; let __v_98: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_36, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_40, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_39, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_78, __v_101]; 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_102: G = __r_arr[0]; let __v_103: G = G::from_u64(1); let __v_104: G = { let __values: [G; 3] = [__v_103, __v_103, __v_103]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_102, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; let __v_108: G = __r_arr[3]; let __v_109: G = __r_arr[4]; let __v_110: G = __r_arr[5]; let __v_111: G = __r_arr[6]; let __v_112: G = __r_arr[7]; let __v_113: G = __r_arr[8]; let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = __r_arr[12]; let __v_118: G = __r_arr[13]; let __v_119: G = __r_arr[14]; let __v_120: G = __r_arr[15]; let __v_121: G = __r_arr[16]; let __v_122: G = __r_arr[17]; let __v_123: G = G::from_u64(256); let __v_124: G = __v_123 * __v_106; let __v_125: G = G::from_u64(65536); let __v_126: G = __v_125 * __v_107; let __v_127: G = G::from_u64(16777216); let __v_128: G = __v_127 * __v_108; let __v_129: G = G::from_u64(4294967296); let __v_130: G = __v_129 * __v_109; let __v_131: G = G::from_u64(1099511627776); let __v_132: G = __v_131 * __v_110; let __v_133: G = G::from_u64(281474976710656); let __v_134: G = __v_133 * __v_111; let __v_135: G = G::from_u64(72057594037927936); let __v_136: G = __v_135 * __v_112; let __v_137: G = __v_134 + __v_136; let __v_138: G = __v_132 + __v_137; let __v_139: G = __v_130 + __v_138; let __v_140: G = __v_128 + __v_139; let __v_141: G = __v_126 + __v_140; let __v_142: G = __v_124 + __v_141; let __v_143: G = __v_105 + __v_142; let __v_144: G = __v_123 * __v_114; let __v_145: G = __v_125 * __v_115; let __v_146: G = __v_127 * __v_116; let __v_147: G = __v_129 * __v_117; let __v_148: G = __v_131 * __v_118; let __v_149: G = __v_133 * __v_119; let __v_150: G = __v_135 * __v_120; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_148 + __v_151; let __v_153: G = __v_147 + __v_152; let __v_154: G = __v_146 + __v_153; let __v_155: G = __v_145 + __v_154; let __v_156: G = __v_144 + __v_155; let __v_157: G = __v_113 + __v_156; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_121, __v_23, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_159, __v_160]; 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_161: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_161, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_162, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = __v_84 + __v_0; let __v_166: G = G::from_u64(33); let __v_167: G = { let __a_val = __v_165.as_canonical_u64(); let __b_val = __v_166.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; if (__v_167 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_163, __v_164, __v_4, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_25, __v_168, __v_18, __v_19, __v_20, __v_73, __v_37, __v_38, __v_61, __v_22, __v_83, __v_0, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; if (__v_169 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_163, __v_164, __v_171, __v_143, __v_157, __v_39, __v_40, __v_36, __v_37, __v_38, __v_18, __v_19, __v_20, __v_73, __v_61, __v_22, __v_76, __v_77, __v_83, __v_0, __v_165, __v_158, __v_23, __v_27, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_173: G = __r_arr[0]; if (__v_173 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, &__args[..])?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_232] = [__v_174, __v_175]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } const INPUT_SIZE_233: usize = 22; const IN_233: usize = 22; const OUT_233: usize = 2; -fn aiur_fn_233(inp: [G; IN_233], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; let __v_26: G = __loaded[4]; let __v_27: G = __loaded[5]; match __v_22.as_canonical_u64() { 1u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; let __v_54: G = G::from_u64(1); if (__v_28 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_29 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_30 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_31 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_32 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_33 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_34 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_35 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_36 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_37 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_38 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_39 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_40 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_41 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_42 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_43 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_44 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_45 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_46 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_47 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_48 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_49 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_50 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_51 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_52 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_53 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_233] = [__v_20, __v_21]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, (&__args[..]))?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { (*(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232])) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_14 + __v_56); let __v_58: G = (__v_20 + __v_54); let __v_59: G = (__v_21 + __v_55); let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_27, __v_53, __v_57, __v_15, __v_16, __v_17, __v_18, __v_19, __v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(233, (&__args[..]))?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { (*(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233])) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_233] = [__v_60, __v_61]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }) } +fn aiur_fn_233(inp: [G; IN_233], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; let __v_26: G = __loaded[4]; let __v_27: G = __loaded[5]; match __v_22.as_canonical_u64() { 1u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; let __v_54: G = G::from_u64(1); if (__v_28 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_29 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_30 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_31 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_32 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_33 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_34 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_35 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_36 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_37 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_38 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_39 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_40 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_41 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_42 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_43 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_44 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_45 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_46 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_47 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_48 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_49 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_50 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_51 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_52 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_53 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_233] = [__v_20, __v_21]; record.function_queries[233].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, &__args[..])?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = __v_14 + __v_56; let __v_58: G = __v_20 + __v_54; let __v_59: G = __v_21 + __v_55; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_27, __v_53, __v_57, __v_15, __v_16, __v_17, __v_18, __v_19, __v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_233] = [__v_60, __v_61]; record.function_queries[233].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }) } const INPUT_SIZE_234: usize = 1; const IN_234: usize = 1; const OUT_234: usize = 1; -fn aiur_fn_234(inp: [G; IN_234], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_234] = [__v_8]; record.function_queries[234].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, (&__args[..]))?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { (*(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234])) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __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_8: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_8]; record.function_queries[234].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_234(inp: [G; IN_234], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_234] = [__v_8]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __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_8: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_8]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_235: usize = 15; const IN_235: usize = 15; const OUT_235: usize = 1; -fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_12]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_14]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_12]; 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_19: G = __r_arr[0]; if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, (&__args[..]))?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { (*(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231])) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_23]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_22: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_7, __v_22, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, (&__args[..]))?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { (*(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216])) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, (&__args[..]))?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { (*(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223])) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_28, __v_27, __v_23, __v_24, __v_25, __v_26, __v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(233, (&__args[..]))?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { (*(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233])) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_bool((__v_31 == G::ZERO)); let __v_34: G = G::from_bool((__v_32 == G::ZERO)); let __v_35: G = (__v_33 * __v_34); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, (&__args[..]))?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { (*(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234])) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_235] = [__v_37]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_12]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_14]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_12]; 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_19: G = __r_arr[0]; if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, &__args[..])?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_23]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_22: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_7, __v_22, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, &__args[..])?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, &__args[..])?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_28, __v_27, __v_23, __v_24, __v_25, __v_26, __v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_bool(__v_31 == G::ZERO); let __v_34: G = G::from_bool(__v_32 == G::ZERO); let __v_35: G = __v_33 * __v_34; let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_235] = [__v_37]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_236: usize = 15; const IN_236: usize = 15; const OUT_236: usize = 1; -fn aiur_fn_236(inp: [G; IN_236], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, (&__args[..]))?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { (*(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65])) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, (&__args[..]))?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { (*(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70])) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = (__v_12 + __v_13); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17, __v_21, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, (&__args[..]))?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { (*(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220])) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_236] = [__v_30]; record.function_queries[236].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_236(inp: [G; IN_236], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __v_12 + __v_13; if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17, __v_21, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, &__args[..])?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_236] = [__v_30]; record.function_queries[236].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_237: usize = 1; const IN_237: usize = 1; const OUT_237: usize = 2; -fn aiur_fn_237(inp: [G; IN_237], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, (&__args[..]))?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, (&__args[..]))?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { (*(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238])) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_237] = [__v_3, __v_4]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_237(inp: [G; IN_237], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_237] = [__v_3, __v_4]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_238: usize = 2; const IN_238: usize = 2; const OUT_238: usize = 2; -fn aiur_fn_238(inp: [G; IN_238], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_238] = [__v_3, __v_0]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, (&__args[..]))?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, (&__args[..]))?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { (*(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238])) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_238] = [__v_11, __v_9]; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_238(inp: [G; IN_238], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_238] = [__v_3, __v_0]; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_238] = [__v_11, __v_9]; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_239: usize = 1; const IN_239: usize = 1; const OUT_239: usize = 2; -fn aiur_fn_239(inp: [G; IN_239], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, (&__args[..]))?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_239] = [__v_3, __v_4]; record.function_queries[239].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_239(inp: [G; IN_239], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_239] = [__v_3, __v_4]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_240: usize = 2; const IN_240: usize = 2; const OUT_240: usize = 2; -fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_240] = [__v_3, __v_0]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_240] = [__v_16, __v_14]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_240] = [__v_3, __v_0]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_240] = [__v_16, __v_14]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_241: usize = 1; const IN_241: usize = 1; const OUT_241: usize = 2; -fn aiur_fn_241(inp: [G; IN_241], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_241] = [__v_97, __v_96]; record.function_queries[241].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())); }, } }) } +fn aiur_fn_241(inp: [G; IN_241], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_241] = [__v_97, __v_96]; record.function_queries[241].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_242: usize = 2; const IN_242: usize = 2; const OUT_242: usize = 1; -fn aiur_fn_242(inp: [G; IN_242], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_34, __v_32, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_34, __v_31, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_34, __v_30, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_34, __v_29, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 3] = [__v_34, __v_28, __v_39]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_27, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_42: G = { let __values: [G; 3] = [__v_34, __v_26, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_43: G = { let __values: [G; 3] = [__v_34, __v_25, __v_42]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_34, __v_24, __v_43]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_45: G = { let __values: [G; 3] = [__v_34, __v_23, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_46: G = { let __values: [G; 3] = [__v_34, __v_22, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_47: G = { let __values: [G; 3] = [__v_34, __v_21, __v_46]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_48: G = { let __values: [G; 3] = [__v_34, __v_20, __v_47]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_49: G = { let __values: [G; 3] = [__v_34, __v_19, __v_48]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_50: G = { let __values: [G; 3] = [__v_34, __v_18, __v_49]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_51: G = { let __values: [G; 3] = [__v_34, __v_17, __v_50]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_52: G = { let __values: [G; 3] = [__v_34, __v_16, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_53: G = { let __values: [G; 3] = [__v_34, __v_15, __v_52]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_54: G = { let __values: [G; 3] = [__v_34, __v_14, __v_53]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 3] = [__v_34, __v_13, __v_54]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 3] = [__v_34, __v_12, __v_55]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 3] = [__v_34, __v_11, __v_56]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_58: G = { let __values: [G; 3] = [__v_34, __v_10, __v_57]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 3] = [__v_34, __v_9, __v_58]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 3] = [__v_34, __v_8, __v_59]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 3] = [__v_34, __v_7, __v_60]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 3] = [__v_34, __v_6, __v_61]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 3] = [__v_34, __v_5, __v_62]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 3] = [__v_34, __v_4, __v_63]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_65: G = { let __values: [G; 3] = [__v_34, __v_3, __v_64]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_66: G = { let __values: [G; 3] = [__v_34, __v_2, __v_65]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_242] = [__v_66]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_34, __v_32, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_34, __v_31, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_34, __v_30, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_34, __v_29, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 3] = [__v_34, __v_28, __v_39]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_27, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_42: G = { let __values: [G; 3] = [__v_34, __v_26, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_43: G = { let __values: [G; 3] = [__v_34, __v_25, __v_42]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_34, __v_24, __v_43]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_45: G = { let __values: [G; 3] = [__v_34, __v_23, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_46: G = { let __values: [G; 3] = [__v_34, __v_22, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_47: G = { let __values: [G; 3] = [__v_34, __v_21, __v_46]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_48: G = { let __values: [G; 3] = [__v_34, __v_20, __v_47]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_49: G = { let __values: [G; 3] = [__v_34, __v_19, __v_48]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_50: G = { let __values: [G; 3] = [__v_34, __v_18, __v_49]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_51: G = { let __values: [G; 3] = [__v_34, __v_17, __v_50]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_52: G = { let __values: [G; 3] = [__v_34, __v_16, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_53: G = { let __values: [G; 3] = [__v_34, __v_15, __v_52]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_54: G = { let __values: [G; 3] = [__v_34, __v_14, __v_53]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 3] = [__v_34, __v_13, __v_54]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 3] = [__v_34, __v_12, __v_55]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 3] = [__v_34, __v_11, __v_56]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_58: G = { let __values: [G; 3] = [__v_34, __v_10, __v_57]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 3] = [__v_34, __v_9, __v_58]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 3] = [__v_34, __v_8, __v_59]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 3] = [__v_34, __v_7, __v_60]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 3] = [__v_34, __v_6, __v_61]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 3] = [__v_34, __v_5, __v_62]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 3] = [__v_34, __v_4, __v_63]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_65: G = { let __values: [G; 3] = [__v_34, __v_3, __v_64]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_66: G = { let __values: [G; 3] = [__v_34, __v_2, __v_65]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_242] = [__v_66]; 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 = 8; -fn aiur_fn_243(inp: [G; IN_243], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(256); let __v_34: G = (__v_33 * __v_2); let __v_35: G = G::from_u64(65536); let __v_36: G = (__v_35 * __v_3); let __v_37: G = G::from_u64(16777216); let __v_38: G = (__v_37 * __v_4); let __v_39: G = (__v_36 + __v_38); let __v_40: G = (__v_34 + __v_39); let __v_41: G = (__v_1 + __v_40); let __v_42: G = (__v_33 * __v_6); let __v_43: G = (__v_35 * __v_7); let __v_44: G = (__v_37 * __v_8); let __v_45: G = (__v_43 + __v_44); let __v_46: G = (__v_42 + __v_45); let __v_47: G = (__v_5 + __v_46); let __v_48: G = (__v_33 * __v_10); let __v_49: G = (__v_35 * __v_11); let __v_50: G = (__v_37 * __v_12); let __v_51: G = (__v_49 + __v_50); let __v_52: G = (__v_48 + __v_51); let __v_53: G = (__v_9 + __v_52); let __v_54: G = (__v_33 * __v_14); let __v_55: G = (__v_35 * __v_15); let __v_56: G = (__v_37 * __v_16); let __v_57: G = (__v_55 + __v_56); let __v_58: G = (__v_54 + __v_57); let __v_59: G = (__v_13 + __v_58); let __v_60: G = (__v_33 * __v_18); let __v_61: G = (__v_35 * __v_19); let __v_62: G = (__v_37 * __v_20); let __v_63: G = (__v_61 + __v_62); let __v_64: G = (__v_60 + __v_63); let __v_65: G = (__v_17 + __v_64); let __v_66: G = (__v_33 * __v_22); let __v_67: G = (__v_35 * __v_23); let __v_68: G = (__v_37 * __v_24); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_66 + __v_69); let __v_71: G = (__v_21 + __v_70); let __v_72: G = (__v_33 * __v_26); let __v_73: G = (__v_35 * __v_27); let __v_74: G = (__v_37 * __v_28); let __v_75: G = (__v_73 + __v_74); let __v_76: G = (__v_72 + __v_75); let __v_77: G = (__v_25 + __v_76); let __v_78: G = (__v_33 * __v_30); let __v_79: G = (__v_35 * __v_31); let __v_80: G = (__v_37 * __v_32); let __v_81: G = (__v_79 + __v_80); let __v_82: G = (__v_78 + __v_81); let __v_83: G = (__v_29 + __v_82); let __ret: [G; OUT_243] = [__v_41, __v_47, __v_53, __v_59, __v_65, __v_71, __v_77, __v_83]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_243(inp: [G; IN_243], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(256); let __v_34: G = __v_33 * __v_2; let __v_35: G = G::from_u64(65536); let __v_36: G = __v_35 * __v_3; let __v_37: G = G::from_u64(16777216); let __v_38: G = __v_37 * __v_4; let __v_39: G = __v_36 + __v_38; let __v_40: G = __v_34 + __v_39; let __v_41: G = __v_1 + __v_40; let __v_42: G = __v_33 * __v_6; let __v_43: G = __v_35 * __v_7; let __v_44: G = __v_37 * __v_8; let __v_45: G = __v_43 + __v_44; let __v_46: G = __v_42 + __v_45; let __v_47: G = __v_5 + __v_46; let __v_48: G = __v_33 * __v_10; let __v_49: G = __v_35 * __v_11; let __v_50: G = __v_37 * __v_12; let __v_51: G = __v_49 + __v_50; let __v_52: G = __v_48 + __v_51; let __v_53: G = __v_9 + __v_52; let __v_54: G = __v_33 * __v_14; let __v_55: G = __v_35 * __v_15; let __v_56: G = __v_37 * __v_16; let __v_57: G = __v_55 + __v_56; let __v_58: G = __v_54 + __v_57; let __v_59: G = __v_13 + __v_58; let __v_60: G = __v_33 * __v_18; let __v_61: G = __v_35 * __v_19; let __v_62: G = __v_37 * __v_20; let __v_63: G = __v_61 + __v_62; let __v_64: G = __v_60 + __v_63; let __v_65: G = __v_17 + __v_64; let __v_66: G = __v_33 * __v_22; let __v_67: G = __v_35 * __v_23; let __v_68: G = __v_37 * __v_24; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_66 + __v_69; let __v_71: G = __v_21 + __v_70; let __v_72: G = __v_33 * __v_26; let __v_73: G = __v_35 * __v_27; let __v_74: G = __v_37 * __v_28; let __v_75: G = __v_73 + __v_74; let __v_76: G = __v_72 + __v_75; let __v_77: G = __v_25 + __v_76; let __v_78: G = __v_33 * __v_30; let __v_79: G = __v_35 * __v_31; let __v_80: G = __v_37 * __v_32; let __v_81: G = __v_79 + __v_80; let __v_82: G = __v_78 + __v_81; let __v_83: G = __v_29 + __v_82; let __ret: [G; OUT_243] = [__v_41, __v_47, __v_53, __v_59, __v_65, __v_71, __v_77, __v_83]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_244: usize = 2; const IN_244: usize = 2; 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 __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_8]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_8]; 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_245: usize = 1; -fn aiur_fn_245(inp: [G; IN_245], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_245] = [__v_6]; 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 = G::from_u64(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_245] = [__v_6]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_246: usize = 4; const IN_246: usize = 4; const OUT_246: usize = 1; -fn aiur_fn_246(inp: [G; IN_246], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_0 * __v_4); let __v_6: G = (__v_5 + __v_1); let __v_7: G = (__v_6 * __v_4); let __v_8: G = (__v_7 + __v_2); let __v_9: G = (__v_8 * __v_4); let __v_10: G = (__v_9 + __v_3); let __ret: [G; OUT_246] = [__v_10]; 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = __v_0 * __v_4; let __v_6: G = __v_5 + __v_1; let __v_7: G = __v_6 * __v_4; let __v_8: G = __v_7 + __v_2; let __v_9: G = __v_8 * __v_4; let __v_10: G = __v_9 + __v_3; let __ret: [G; OUT_246] = [__v_10]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_247: usize = 2; const IN_247: usize = 2; const OUT_247: usize = 1; -fn aiur_fn_247(inp: [G; IN_247], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = G::from_u64(256); let __v_67: G = (__v_2 * __v_66); let __v_68: G = (__v_67 + __v_3); let __v_69: G = (__v_68 * __v_66); let __v_70: G = (__v_69 + __v_4); let __v_71: G = (__v_70 * __v_66); let __v_72: G = (__v_71 + __v_5); let __v_73: G = (__v_34 * __v_66); let __v_74: G = (__v_73 + __v_35); let __v_75: G = (__v_74 * __v_66); let __v_76: G = (__v_75 + __v_36); let __v_77: G = (__v_76 * __v_66); let __v_78: G = (__v_77 + __v_37); let __v_79: G = (__v_72 - __v_78); match __v_79.as_canonical_u64() { 0u64 => { let __v_80: G = G::from_u64(256); let __v_81: G = (__v_6 * __v_80); let __v_82: G = (__v_81 + __v_7); let __v_83: G = (__v_82 * __v_80); let __v_84: G = (__v_83 + __v_8); let __v_85: G = (__v_84 * __v_80); let __v_86: G = (__v_85 + __v_9); let __v_87: G = (__v_38 * __v_80); let __v_88: G = (__v_87 + __v_39); let __v_89: G = (__v_88 * __v_80); let __v_90: G = (__v_89 + __v_40); let __v_91: G = (__v_90 * __v_80); let __v_92: G = (__v_91 + __v_41); let __v_93: G = (__v_86 - __v_92); match __v_93.as_canonical_u64() { 0u64 => { let __v_94: G = G::from_u64(256); let __v_95: G = (__v_10 * __v_94); let __v_96: G = (__v_95 + __v_11); let __v_97: G = (__v_96 * __v_94); let __v_98: G = (__v_97 + __v_12); let __v_99: G = (__v_98 * __v_94); let __v_100: G = (__v_99 + __v_13); let __v_101: G = (__v_42 * __v_94); let __v_102: G = (__v_101 + __v_43); let __v_103: G = (__v_102 * __v_94); let __v_104: G = (__v_103 + __v_44); let __v_105: G = (__v_104 * __v_94); let __v_106: G = (__v_105 + __v_45); let __v_107: G = (__v_100 - __v_106); match __v_107.as_canonical_u64() { 0u64 => { let __v_108: G = G::from_u64(256); let __v_109: G = (__v_14 * __v_108); let __v_110: G = (__v_109 + __v_15); let __v_111: G = (__v_110 * __v_108); let __v_112: G = (__v_111 + __v_16); let __v_113: G = (__v_112 * __v_108); let __v_114: G = (__v_113 + __v_17); let __v_115: G = (__v_46 * __v_108); let __v_116: G = (__v_115 + __v_47); let __v_117: G = (__v_116 * __v_108); let __v_118: G = (__v_117 + __v_48); let __v_119: G = (__v_118 * __v_108); let __v_120: G = (__v_119 + __v_49); let __v_121: G = (__v_114 - __v_120); match __v_121.as_canonical_u64() { 0u64 => { let __v_122: G = G::from_u64(256); let __v_123: G = (__v_18 * __v_122); let __v_124: G = (__v_123 + __v_19); let __v_125: G = (__v_124 * __v_122); let __v_126: G = (__v_125 + __v_20); let __v_127: G = (__v_126 * __v_122); let __v_128: G = (__v_127 + __v_21); let __v_129: G = (__v_50 * __v_122); let __v_130: G = (__v_129 + __v_51); let __v_131: G = (__v_130 * __v_122); let __v_132: G = (__v_131 + __v_52); let __v_133: G = (__v_132 * __v_122); let __v_134: G = (__v_133 + __v_53); let __v_135: G = (__v_128 - __v_134); match __v_135.as_canonical_u64() { 0u64 => { let __v_136: G = G::from_u64(256); let __v_137: G = (__v_22 * __v_136); let __v_138: G = (__v_137 + __v_23); let __v_139: G = (__v_138 * __v_136); let __v_140: G = (__v_139 + __v_24); let __v_141: G = (__v_140 * __v_136); let __v_142: G = (__v_141 + __v_25); let __v_143: G = (__v_54 * __v_136); let __v_144: G = (__v_143 + __v_55); let __v_145: G = (__v_144 * __v_136); let __v_146: G = (__v_145 + __v_56); let __v_147: G = (__v_146 * __v_136); let __v_148: G = (__v_147 + __v_57); let __v_149: G = (__v_142 - __v_148); match __v_149.as_canonical_u64() { 0u64 => { let __v_150: G = G::from_u64(256); let __v_151: G = (__v_26 * __v_150); let __v_152: G = (__v_151 + __v_27); let __v_153: G = (__v_152 * __v_150); let __v_154: G = (__v_153 + __v_28); let __v_155: G = (__v_154 * __v_150); let __v_156: G = (__v_155 + __v_29); let __v_157: G = (__v_58 * __v_150); let __v_158: G = (__v_157 + __v_59); let __v_159: G = (__v_158 * __v_150); let __v_160: G = (__v_159 + __v_60); let __v_161: G = (__v_160 * __v_150); let __v_162: G = (__v_161 + __v_61); let __v_163: G = (__v_156 - __v_162); match __v_163.as_canonical_u64() { 0u64 => { let __v_164: G = G::from_u64(256); let __v_165: G = (__v_30 * __v_164); let __v_166: G = (__v_165 + __v_31); let __v_167: G = (__v_166 * __v_164); let __v_168: G = (__v_167 + __v_32); let __v_169: G = (__v_168 * __v_164); let __v_170: G = (__v_169 + __v_33); let __v_171: G = (__v_62 * __v_164); let __v_172: G = (__v_171 + __v_63); let __v_173: G = (__v_172 * __v_164); let __v_174: G = (__v_173 + __v_64); let __v_175: G = (__v_174 * __v_164); let __v_176: G = (__v_175 + __v_65); let __v_177: G = (__v_170 - __v_176); match __v_177.as_canonical_u64() { 0u64 => { let __v_178: G = G::from_u64(1); let __ret: [G; OUT_247] = [__v_178]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_178: G = { let __a_val = __v_170.as_canonical_u64(); let __b_val = __v_176.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_178.as_canonical_u64() { 1u64 => { let __v_179: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_179]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_179: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_179]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_164: G = { let __a_val = __v_156.as_canonical_u64(); let __b_val = __v_162.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_164.as_canonical_u64() { 1u64 => { let __v_165: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_165]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_165: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_165]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_150: G = { let __a_val = __v_142.as_canonical_u64(); let __b_val = __v_148.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_150.as_canonical_u64() { 1u64 => { let __v_151: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_151]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_151: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_151]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_136: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_134.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_136.as_canonical_u64() { 1u64 => { let __v_137: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_137]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_137: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_137]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_122: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_120.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_122.as_canonical_u64() { 1u64 => { let __v_123: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_123]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_123: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_123]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_108: G = { let __a_val = __v_100.as_canonical_u64(); let __b_val = __v_106.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_108.as_canonical_u64() { 1u64 => { let __v_109: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_109]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_109: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_109]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_94: G = { let __a_val = __v_86.as_canonical_u64(); let __b_val = __v_92.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_94.as_canonical_u64() { 1u64 => { let __v_95: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_95]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_95: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_95]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_80: G = { let __a_val = __v_72.as_canonical_u64(); let __b_val = __v_78.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_80.as_canonical_u64() { 1u64 => { let __v_81: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_81]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_81: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_81]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_247(inp: [G; IN_247], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = G::from_u64(256); let __v_67: G = __v_2 * __v_66; let __v_68: G = __v_67 + __v_3; let __v_69: G = __v_68 * __v_66; let __v_70: G = __v_69 + __v_4; let __v_71: G = __v_70 * __v_66; let __v_72: G = __v_71 + __v_5; let __v_73: G = __v_34 * __v_66; let __v_74: G = __v_73 + __v_35; let __v_75: G = __v_74 * __v_66; let __v_76: G = __v_75 + __v_36; let __v_77: G = __v_76 * __v_66; let __v_78: G = __v_77 + __v_37; let __v_79: G = __v_72 - __v_78; match __v_79.as_canonical_u64() { 0u64 => { let __v_80: G = G::from_u64(256); let __v_81: G = __v_6 * __v_80; let __v_82: G = __v_81 + __v_7; let __v_83: G = __v_82 * __v_80; let __v_84: G = __v_83 + __v_8; let __v_85: G = __v_84 * __v_80; let __v_86: G = __v_85 + __v_9; let __v_87: G = __v_38 * __v_80; let __v_88: G = __v_87 + __v_39; let __v_89: G = __v_88 * __v_80; let __v_90: G = __v_89 + __v_40; let __v_91: G = __v_90 * __v_80; let __v_92: G = __v_91 + __v_41; let __v_93: G = __v_86 - __v_92; match __v_93.as_canonical_u64() { 0u64 => { let __v_94: G = G::from_u64(256); let __v_95: G = __v_10 * __v_94; let __v_96: G = __v_95 + __v_11; let __v_97: G = __v_96 * __v_94; let __v_98: G = __v_97 + __v_12; let __v_99: G = __v_98 * __v_94; let __v_100: G = __v_99 + __v_13; let __v_101: G = __v_42 * __v_94; let __v_102: G = __v_101 + __v_43; let __v_103: G = __v_102 * __v_94; let __v_104: G = __v_103 + __v_44; let __v_105: G = __v_104 * __v_94; let __v_106: G = __v_105 + __v_45; let __v_107: G = __v_100 - __v_106; match __v_107.as_canonical_u64() { 0u64 => { let __v_108: G = G::from_u64(256); let __v_109: G = __v_14 * __v_108; let __v_110: G = __v_109 + __v_15; let __v_111: G = __v_110 * __v_108; let __v_112: G = __v_111 + __v_16; let __v_113: G = __v_112 * __v_108; let __v_114: G = __v_113 + __v_17; let __v_115: G = __v_46 * __v_108; let __v_116: G = __v_115 + __v_47; let __v_117: G = __v_116 * __v_108; let __v_118: G = __v_117 + __v_48; let __v_119: G = __v_118 * __v_108; let __v_120: G = __v_119 + __v_49; let __v_121: G = __v_114 - __v_120; match __v_121.as_canonical_u64() { 0u64 => { let __v_122: G = G::from_u64(256); let __v_123: G = __v_18 * __v_122; let __v_124: G = __v_123 + __v_19; let __v_125: G = __v_124 * __v_122; let __v_126: G = __v_125 + __v_20; let __v_127: G = __v_126 * __v_122; let __v_128: G = __v_127 + __v_21; let __v_129: G = __v_50 * __v_122; let __v_130: G = __v_129 + __v_51; let __v_131: G = __v_130 * __v_122; let __v_132: G = __v_131 + __v_52; let __v_133: G = __v_132 * __v_122; let __v_134: G = __v_133 + __v_53; let __v_135: G = __v_128 - __v_134; match __v_135.as_canonical_u64() { 0u64 => { let __v_136: G = G::from_u64(256); let __v_137: G = __v_22 * __v_136; let __v_138: G = __v_137 + __v_23; let __v_139: G = __v_138 * __v_136; let __v_140: G = __v_139 + __v_24; let __v_141: G = __v_140 * __v_136; let __v_142: G = __v_141 + __v_25; let __v_143: G = __v_54 * __v_136; let __v_144: G = __v_143 + __v_55; let __v_145: G = __v_144 * __v_136; let __v_146: G = __v_145 + __v_56; let __v_147: G = __v_146 * __v_136; let __v_148: G = __v_147 + __v_57; let __v_149: G = __v_142 - __v_148; match __v_149.as_canonical_u64() { 0u64 => { let __v_150: G = G::from_u64(256); let __v_151: G = __v_26 * __v_150; let __v_152: G = __v_151 + __v_27; let __v_153: G = __v_152 * __v_150; let __v_154: G = __v_153 + __v_28; let __v_155: G = __v_154 * __v_150; let __v_156: G = __v_155 + __v_29; let __v_157: G = __v_58 * __v_150; let __v_158: G = __v_157 + __v_59; let __v_159: G = __v_158 * __v_150; let __v_160: G = __v_159 + __v_60; let __v_161: G = __v_160 * __v_150; let __v_162: G = __v_161 + __v_61; let __v_163: G = __v_156 - __v_162; match __v_163.as_canonical_u64() { 0u64 => { let __v_164: G = G::from_u64(256); let __v_165: G = __v_30 * __v_164; let __v_166: G = __v_165 + __v_31; let __v_167: G = __v_166 * __v_164; let __v_168: G = __v_167 + __v_32; let __v_169: G = __v_168 * __v_164; let __v_170: G = __v_169 + __v_33; let __v_171: G = __v_62 * __v_164; let __v_172: G = __v_171 + __v_63; let __v_173: G = __v_172 * __v_164; let __v_174: G = __v_173 + __v_64; let __v_175: G = __v_174 * __v_164; let __v_176: G = __v_175 + __v_65; let __v_177: G = __v_170 - __v_176; match __v_177.as_canonical_u64() { 0u64 => { let __v_178: G = G::from_u64(1); let __ret: [G; OUT_247] = [__v_178]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_178: G = { let __a_val = __v_170.as_canonical_u64(); let __b_val = __v_176.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_178.as_canonical_u64() { 1u64 => { let __v_179: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_179]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_179: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_179]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_164: G = { let __a_val = __v_156.as_canonical_u64(); let __b_val = __v_162.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_164.as_canonical_u64() { 1u64 => { let __v_165: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_165]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_165: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_165]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_150: G = { let __a_val = __v_142.as_canonical_u64(); let __b_val = __v_148.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_150.as_canonical_u64() { 1u64 => { let __v_151: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_151]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_151: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_151]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_136: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_134.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_136.as_canonical_u64() { 1u64 => { let __v_137: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_137]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_137: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_137]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_122: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_120.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_122.as_canonical_u64() { 1u64 => { let __v_123: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_123]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_123: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_123]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_108: G = { let __a_val = __v_100.as_canonical_u64(); let __b_val = __v_106.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_108.as_canonical_u64() { 1u64 => { let __v_109: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_109]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_109: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_109]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_94: G = { let __a_val = __v_86.as_canonical_u64(); let __b_val = __v_92.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_94.as_canonical_u64() { 1u64 => { let __v_95: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_95]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_95: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_95]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_80: G = { let __a_val = __v_72.as_canonical_u64(); let __b_val = __v_78.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_80.as_canonical_u64() { 1u64 => { let __v_81: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_81]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_81: G = G::from_u64(2); let __ret: [G; OUT_247] = [__v_81]; 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 = 0; -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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_248] = []; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_248] = []; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: tree leaves are not strictly sorted".to_string()) }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_3]; 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 __ret: [G; OUT_248] = []; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_248] = []; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_248] = []; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: tree leaves are not strictly sorted".to_string()) }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_3]; 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 __ret: [G; OUT_248] = []; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_249: usize = 1; const IN_249: usize = 1; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_249] = [__v_8, __v_4]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_249] = [__v_4, __v_2]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, (&__args[..]))?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { (*(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298])) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_249] = [__v_7, __v_6]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_249(inp: [G; IN_249], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_249] = [__v_8, __v_4]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_249] = [__v_4, __v_2]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_249] = [__v_7, __v_6]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_250: usize = 1; const IN_250: usize = 1; const OUT_250: usize = 1; -fn aiur_fn_250(inp: [G; IN_250], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_250] = [__v_5]; record.function_queries[250].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, (&__args[..]))?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { (*(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245])) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_250] = [__v_7]; record.function_queries[250].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_250(inp: [G; IN_250], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_250] = [__v_5]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, &__args[..])?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_250] = [__v_7]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_251: usize = 1; const IN_251: usize = 1; 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_5]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 32] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_7, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_12]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_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 = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_10]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_251(inp: [G; IN_251], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_5]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 32] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_7, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_12]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_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 = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_10]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_252: usize = 1; const IN_252: usize = 1; const OUT_252: usize = 1; -fn aiur_fn_252(inp: [G; IN_252], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_252] = [__v_2]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; 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 __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_8]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_252(inp: [G; IN_252], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_252] = [__v_2]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; 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 __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_8]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_253: usize = 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 __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_1: G = __r_arr[0]; let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1]; 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_2: G = __r_arr[0]; let __ret: [G; OUT_253] = [__v_2]; 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_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_1: G = __r_arr[0]; let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1]; 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_2: G = __r_arr[0]; let __ret: [G; OUT_253] = [__v_2]; 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 = 1; -fn aiur_fn_254(inp: [G; IN_254], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(5); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_33, __v_34, __v_35]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(226); if (__v_37 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("aggr: tree has the wrong Ixon tag".to_string()) }); } let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_38]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_42: G = __loaded[0]; let __v_43: G = __loaded[1]; let __v_44: G = __loaded[2]; let __v_45: G = G::from_u64(1); if (__v_42 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } if (__v_43 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_40]; 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_46: G = __r_arr[0]; let __v_47: G = G::from_u64(0); if (__v_46 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr: a present tree must contain at least one leaf".to_string()) }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_40]; 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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_40]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_48, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; if (__v_49 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: tree leaves do not reproduce the canonical root".to_string()) }); } let __ret: [G; OUT_254] = [__v_40]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(5); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_33, __v_34, __v_35]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(226); if (__v_37 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("aggr: tree has the wrong Ixon tag".to_string()) }); } let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_38]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_42: G = __loaded[0]; let __v_43: G = __loaded[1]; let __v_44: G = __loaded[2]; let __v_45: G = G::from_u64(1); if (__v_42 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } if (__v_43 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_40]; 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_46: G = __r_arr[0]; let __v_47: G = G::from_u64(0); if (__v_46 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr: a present tree must contain at least one leaf".to_string()) }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_40]; 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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_40]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_48, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; if (__v_49 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: tree leaves do not reproduce the canonical root".to_string()) }); } let __ret: [G; OUT_254] = [__v_40]; 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]; match __v_0.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_255] = [__v_3]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { 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_2: G = __r_arr[0]; let __ret: [G; OUT_255] = [__v_2]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_255(inp: [G; IN_255], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_255] = [__v_3]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { 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_2: G = __r_arr[0]; let __ret: [G; OUT_255] = [__v_2]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_256: usize = 2; const IN_256: usize = 2; const OUT_256: usize = 0; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_256] = []; record.function_queries[256].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: set element mismatch".to_string()) }); } let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_4, __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 __ret: [G; OUT_256] = []; record.function_queries[256].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_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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_256] = []; record.function_queries[256].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: set element mismatch".to_string()) }); } let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_4, __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 __ret: [G; OUT_256] = []; record.function_queries[256].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_257: usize = 3; const IN_257: usize = 3; const OUT_257: usize = 0; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __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 __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __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 __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, (&__args[..]))?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { (*(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257])) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, (&__args[..]))?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { (*(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257])) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, (&__args[..]))?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { (*(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257])) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_257] = []; record.function_queries[257].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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __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 __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __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 __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_257] = []; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_257] = []; record.function_queries[257].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_258: usize = 2; const IN_258: usize = 2; const OUT_258: usize = 4; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_258] = [__v_8, __v_8, __v_8, __v_8]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_8, __v_6, __v_0, __v_7]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_8, __v_3, __v_4, __v_1]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_9, __v_3, __v_4, __v_1]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_9, __v_3, __v_4, __v_7]; record.function_queries[258].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_9, __v_6, __v_0, __v_7]; record.function_queries[258].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_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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_258] = [__v_8, __v_8, __v_8, __v_8]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_8, __v_6, __v_0, __v_7]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_8, __v_3, __v_4, __v_1]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_9, __v_3, __v_4, __v_1]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_9, __v_3, __v_4, __v_7]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_258] = [__v_9, __v_6, __v_0, __v_7]; record.function_queries[258].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_259: usize = 2; const IN_259: usize = 2; const OUT_259: usize = 2; -fn aiur_fn_259(inp: [G; IN_259], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_259] = [__v_5, __v_1]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_3, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_4]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_259] = [__v_6, __v_7]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_259] = [__v_6, __v_4]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_6, __v_1]; record.function_queries[259].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_259(inp: [G; IN_259], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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_259] = [__v_5, __v_1]; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_3, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_4]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_259] = [__v_6, __v_7]; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_259] = [__v_6, __v_4]; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_259] = [__v_6, __v_1]; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_260: usize = 4; const IN_260: usize = 4; const OUT_260: usize = 0; -fn aiur_fn_260(inp: [G; IN_260], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; 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 __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = G::from_u64(1); if (__v_8 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } if (__v_9 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, (&__args[..]))?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { (*(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259])) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __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_260] = { let __args: [G; IN_260] = [__v_6, __v_7, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, (&__args[..]))?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { (*(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260])) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: outstanding assumption mismatch".to_string()) }); } let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_6, __v_7, __v_9, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, (&__args[..]))?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { (*(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260])) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +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 __v_3: G = inp[3]; 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 __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = G::from_u64(1); if (__v_8 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } if (__v_9 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __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_260] = { let __args: [G; IN_260] = [__v_6, __v_7, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: outstanding assumption mismatch".to_string()) }); } let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_6, __v_7, __v_9, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_261] = [__v_0, __v_2]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(2); let __v_6: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_3), (&__v_5)) } else { aiur::execute::bytes2_less_than_value(__v_3, __v_5, record) }; let __v_7: G = G::from_u64(1); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr structural: path side must be 0 or 1".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_10, __v_12, __v_9]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_261] = [__v_13, __v_14]; record.function_queries[261].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_261] = [__v_0, __v_2]; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(2); let __v_6: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_3, &__v_5) } else { aiur::execute::bytes2_less_than_value(__v_3, __v_5, record) }; let __v_7: G = G::from_u64(1); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr structural: path side must be 0 or 1".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_10, __v_12, __v_9]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_261] = [__v_13, __v_14]; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_262: usize = 2; const IN_262: usize = 2; const OUT_262: usize = 1; -fn aiur_fn_262(inp: [G; IN_262], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(6); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_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 __io_pair: (G, G) = { let __key: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __info = io_buffer.get_info(__v_2, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_35: G = __io_pair.0; let __v_36: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_2, __v_35, __v_36]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(2); let __v_41: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_38), (&__v_40)) } else { aiur::execute::bytes2_less_than_value(__v_38, __v_40, record) }; let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("aggr structural: discharge choice must be 0 or 1".to_string()) }); } match __v_38.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; let __v_46: G = G::from_u64(1); if (__v_43 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } if (__v_44 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } if (__v_45 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } let __v_47: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_47]; record.function_queries[262].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(65); let __v_46: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_43), (&__v_45)) } else { aiur::execute::bytes2_less_than_value(__v_43, __v_45, record) }; let __v_47: G = G::from_u64(1); if (__v_46 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: Merkle path exceeds 64 steps".to_string()) }); } let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, (&__args[..]))?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { (*(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245])) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_48, __v_43, __v_44]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; if (__v_51 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } if (__v_52 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } if (__v_53 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_49, __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_54: G = __r_arr[0]; if (__v_54 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: assumption path does not reach subject root".to_string()) }); } let __ret: [G; OUT_262] = [__v_47]; record.function_queries[262].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = G::from_u64(6); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_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 __io_pair: (G, G) = { let __key: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __info = io_buffer.get_info(__v_2, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_35: G = __io_pair.0; let __v_36: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_2, __v_35, __v_36]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(2); let __v_41: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_38, &__v_40) } else { aiur::execute::bytes2_less_than_value(__v_38, __v_40, record) }; let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("aggr structural: discharge choice must be 0 or 1".to_string()) }); } match __v_38.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; let __v_46: G = G::from_u64(1); if (__v_43 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } if (__v_44 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } if (__v_45 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } let __v_47: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_47]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(65); let __v_46: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_43, &__v_45) } else { aiur::execute::bytes2_less_than_value(__v_43, __v_45, record) }; let __v_47: G = G::from_u64(1); if (__v_46 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: Merkle path exceeds 64 steps".to_string()) }); } let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, &__args[..])?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_48, __v_43, __v_44]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; if (__v_51 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } if (__v_52 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } if (__v_53 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_49, __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_54: G = __r_arr[0]; if (__v_54 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: assumption path does not reach subject root".to_string()) }); } let __ret: [G; OUT_262] = [__v_47]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_263: usize = 4; const IN_263: usize = 4; const OUT_263: usize = 0; -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 __v_3: G = inp[3]; 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 __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = G::from_u64(1); if (__v_8 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } if (__v_9 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_263] = []; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_5, __v_2]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_6, __v_7, __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 __ret: [G; OUT_263] = []; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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_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("aggr structural: outstanding assumption mismatch".to_string()) }); } let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_6, __v_7, __v_2, __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 __ret: [G; OUT_263] = []; record.function_queries[263].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.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 __v_3: G = inp[3]; 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 __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = G::from_u64(1); if (__v_8 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } if (__v_9 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_263] = []; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_5, __v_2]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_6, __v_7, __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 __ret: [G; OUT_263] = []; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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_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("aggr structural: outstanding assumption mismatch".to_string()) }); } let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_6, __v_7, __v_2, __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 __ret: [G; OUT_263] = []; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_264: usize = 1; const IN_264: usize = 1; const OUT_264: usize = 3; -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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_264] = [__v_3, __v_3, __v_2]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_264] = [__v_5, __v_3, __v_4]; record.function_queries[264].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_264] = [__v_3, __v_3, __v_2]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_264] = [__v_5, __v_3, __v_4]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } 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(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); }) } +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; -fn aiur_fn_266(inp: [G; IN_266], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(4); let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_8, __v_9, __v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 8] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_47: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_48: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_44, __v_45, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = G::from_u64(256); let __v_83: G = (__v_82 * __v_51); let __v_84: G = G::from_u64(65536); let __v_85: G = (__v_84 * __v_52); let __v_86: G = G::from_u64(16777216); let __v_87: G = (__v_86 * __v_53); let __v_88: G = (__v_85 + __v_87); let __v_89: G = (__v_83 + __v_88); let __v_90: G = (__v_50 + __v_89); let __v_91: G = (__v_82 * __v_55); let __v_92: G = (__v_84 * __v_56); let __v_93: G = (__v_86 * __v_57); let __v_94: G = (__v_92 + __v_93); let __v_95: G = (__v_91 + __v_94); let __v_96: G = (__v_54 + __v_95); let __v_97: G = (__v_82 * __v_59); let __v_98: G = (__v_84 * __v_60); let __v_99: G = (__v_86 * __v_61); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_97 + __v_100); let __v_102: G = (__v_58 + __v_101); let __v_103: G = (__v_82 * __v_63); let __v_104: G = (__v_84 * __v_64); let __v_105: G = (__v_86 * __v_65); let __v_106: G = (__v_104 + __v_105); let __v_107: G = (__v_103 + __v_106); let __v_108: G = (__v_62 + __v_107); let __v_109: G = (__v_82 * __v_67); let __v_110: G = (__v_84 * __v_68); let __v_111: G = (__v_86 * __v_69); let __v_112: G = (__v_110 + __v_111); let __v_113: G = (__v_109 + __v_112); let __v_114: G = (__v_66 + __v_113); let __v_115: G = (__v_82 * __v_71); let __v_116: G = (__v_84 * __v_72); let __v_117: G = (__v_86 * __v_73); let __v_118: G = (__v_116 + __v_117); let __v_119: G = (__v_115 + __v_118); let __v_120: G = (__v_70 + __v_119); let __v_121: G = (__v_82 * __v_75); let __v_122: G = (__v_84 * __v_76); let __v_123: G = (__v_86 * __v_77); let __v_124: G = (__v_122 + __v_123); let __v_125: G = (__v_121 + __v_124); let __v_126: G = (__v_74 + __v_125); let __v_127: G = (__v_82 * __v_79); let __v_128: G = (__v_84 * __v_80); let __v_129: G = (__v_86 * __v_81); let __v_130: G = (__v_128 + __v_129); let __v_131: G = (__v_127 + __v_130); let __v_132: G = (__v_78 + __v_131); if (__v_90 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_96 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_108 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_114 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_120 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_126 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_132 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } let __ret: [G; OUT_266] = [__v_11]; record.function_queries[266].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_266(inp: [G; IN_266], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(4); let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_8, __v_9, __v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 8] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_47: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_48: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_44, __v_45, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_51; let __v_84: G = G::from_u64(65536); let __v_85: G = __v_84 * __v_52; let __v_86: G = G::from_u64(16777216); let __v_87: G = __v_86 * __v_53; let __v_88: G = __v_85 + __v_87; let __v_89: G = __v_83 + __v_88; let __v_90: G = __v_50 + __v_89; let __v_91: G = __v_82 * __v_55; let __v_92: G = __v_84 * __v_56; let __v_93: G = __v_86 * __v_57; let __v_94: G = __v_92 + __v_93; let __v_95: G = __v_91 + __v_94; let __v_96: G = __v_54 + __v_95; let __v_97: G = __v_82 * __v_59; let __v_98: G = __v_84 * __v_60; let __v_99: G = __v_86 * __v_61; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_97 + __v_100; let __v_102: G = __v_58 + __v_101; let __v_103: G = __v_82 * __v_63; let __v_104: G = __v_84 * __v_64; let __v_105: G = __v_86 * __v_65; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_103 + __v_106; let __v_108: G = __v_62 + __v_107; let __v_109: G = __v_82 * __v_67; let __v_110: G = __v_84 * __v_68; let __v_111: G = __v_86 * __v_69; let __v_112: G = __v_110 + __v_111; let __v_113: G = __v_109 + __v_112; let __v_114: G = __v_66 + __v_113; let __v_115: G = __v_82 * __v_71; let __v_116: G = __v_84 * __v_72; let __v_117: G = __v_86 * __v_73; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_115 + __v_118; let __v_120: G = __v_70 + __v_119; let __v_121: G = __v_82 * __v_75; let __v_122: G = __v_84 * __v_76; let __v_123: G = __v_86 * __v_77; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_121 + __v_124; let __v_126: G = __v_74 + __v_125; let __v_127: G = __v_82 * __v_79; let __v_128: G = __v_84 * __v_80; let __v_129: G = __v_86 * __v_81; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_127 + __v_130; let __v_132: G = __v_78 + __v_131; if (__v_90 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_96 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_108 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_114 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_120 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_126 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_132 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } let __ret: [G; OUT_266] = [__v_11]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_267: usize = 2; const IN_267: usize = 2; const OUT_267: usize = 1; -fn aiur_fn_267(inp: [G; IN_267], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_3); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_9); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_2 + __v_29); let __ret: [G; OUT_267] = [__v_30]; record.function_queries[267].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_3; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_9; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_2 + __v_29; let __ret: [G; OUT_267] = [__v_30]; 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 = 8; -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 __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, (&__args[..]))?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { (*(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267])) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_267] = { let __args: [G; IN_267] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = (__v_1 + __v_6); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, (&__args[..]))?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { (*(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267])) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(3); let __v_10: G = (__v_1 + __v_9); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(4); let __v_13: G = (__v_1 + __v_12); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(5); let __v_16: G = (__v_1 + __v_15); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(6); let __v_19: G = (__v_1 + __v_18); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __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 __v_21: G = G::from_u64(7); let __v_22: G = (__v_1 + __v_21); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_22]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; record.function_queries[268].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, &__args[..])?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_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_267] = { let __args: [G; IN_267] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, &__args[..])?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(3); let __v_10: G = __v_1 + __v_9; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(4); let __v_13: G = __v_1 + __v_12; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(5); let __v_16: G = __v_1 + __v_15; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(6); let __v_19: G = __v_1 + __v_18; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __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 __v_21: G = G::from_u64(7); let __v_22: G = __v_1 + __v_21; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_22]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; record.function_queries[268].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_269: usize = 16; const IN_269: usize = 16; const OUT_269: usize = 0; -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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; if (__v_0 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_1 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_2 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_3 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_4 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_6 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_7 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_269] = []; record.function_queries[269].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; if (__v_0 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_1 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_2 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_3 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_4 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_6 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_7 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_269] = []; 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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = G::from_u64(1); if (__v_4 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } if (__v_5 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } let __ret: [G; OUT_270] = [__v_2]; record.function_queries[270].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = G::from_u64(1); if (__v_4 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } if (__v_5 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } let __ret: [G; OUT_270] = [__v_2]; record.function_queries[270].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_271: usize = 17; const IN_271: usize = 17; const OUT_271: usize = 12; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_17, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_17, __v_18, __v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(103); let __v_22: G = G::from_u64(230); let __v_23: G = G::from_u64(9); let __v_24: G = G::from_u64(106); let __v_25: G = G::from_u64(133); let __v_26: G = G::from_u64(174); let __v_27: G = G::from_u64(187); let __v_28: G = G::from_u64(114); let __v_29: G = G::from_u64(243); let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(60); let __v_32: G = G::from_u64(58); let __v_33: G = G::from_u64(245); let __v_34: G = G::from_u64(79); let __v_35: G = G::from_u64(165); let __v_36: G = G::from_u64(127); let __v_37: G = G::from_u64(82); let __v_38: G = G::from_u64(14); let __v_39: G = G::from_u64(81); let __v_40: G = G::from_u64(140); let __v_41: G = G::from_u64(104); let __v_42: G = G::from_u64(5); let __v_43: G = G::from_u64(155); let __v_44: G = G::from_u64(171); let __v_45: G = G::from_u64(217); let __v_46: G = G::from_u64(131); let __v_47: G = G::from_u64(31); let __v_48: G = G::from_u64(25); let __v_49: G = G::from_u64(205); let __v_50: G = G::from_u64(224); let __v_51: G = G::from_u64(91); let __v_52: G = { let __values: [G; 3] = [__v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_53: G = G::from_u64(0); let __v_54: G = { let __values: [G; 8] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 32] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_21, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 34] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_20, __v_52, __v_53, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; let __v_67: G = __r_arr[9]; let __v_68: G = __r_arr[10]; let __v_69: G = __r_arr[11]; let __v_70: G = __r_arr[12]; let __v_71: G = __r_arr[13]; let __v_72: G = __r_arr[14]; let __v_73: G = __r_arr[15]; let __v_74: G = __r_arr[16]; let __v_75: G = __r_arr[17]; let __v_76: G = __r_arr[18]; let __v_77: G = __r_arr[19]; let __v_78: G = __r_arr[20]; let __v_79: G = __r_arr[21]; let __v_80: G = __r_arr[22]; let __v_81: G = __r_arr[23]; let __v_82: G = __r_arr[24]; let __v_83: G = __r_arr[25]; let __v_84: G = __r_arr[26]; let __v_85: G = __r_arr[27]; let __v_86: G = __r_arr[28]; let __v_87: G = __r_arr[29]; let __v_88: G = __r_arr[30]; let __v_89: G = __r_arr[31]; let __v_90: G = G::from_u64(256); let __v_91: G = (__v_90 * __v_59); let __v_92: G = G::from_u64(65536); let __v_93: G = (__v_92 * __v_60); let __v_94: G = G::from_u64(16777216); let __v_95: G = (__v_94 * __v_61); let __v_96: G = (__v_93 + __v_95); let __v_97: G = (__v_91 + __v_96); let __v_98: G = (__v_58 + __v_97); let __v_99: G = (__v_90 * __v_63); let __v_100: G = (__v_92 * __v_64); let __v_101: G = (__v_94 * __v_65); let __v_102: G = (__v_100 + __v_101); let __v_103: G = (__v_99 + __v_102); let __v_104: G = (__v_62 + __v_103); let __v_105: G = (__v_90 * __v_67); let __v_106: G = (__v_92 * __v_68); let __v_107: G = (__v_94 * __v_69); let __v_108: G = (__v_106 + __v_107); let __v_109: G = (__v_105 + __v_108); let __v_110: G = (__v_66 + __v_109); let __v_111: G = (__v_90 * __v_71); let __v_112: G = (__v_92 * __v_72); let __v_113: G = (__v_94 * __v_73); let __v_114: G = (__v_112 + __v_113); let __v_115: G = (__v_111 + __v_114); let __v_116: G = (__v_70 + __v_115); let __v_117: G = (__v_90 * __v_75); let __v_118: G = (__v_92 * __v_76); let __v_119: G = (__v_94 * __v_77); let __v_120: G = (__v_118 + __v_119); let __v_121: G = (__v_117 + __v_120); let __v_122: G = (__v_74 + __v_121); let __v_123: G = (__v_90 * __v_79); let __v_124: G = (__v_92 * __v_80); let __v_125: G = (__v_94 * __v_81); let __v_126: G = (__v_124 + __v_125); let __v_127: G = (__v_123 + __v_126); let __v_128: G = (__v_78 + __v_127); let __v_129: G = (__v_90 * __v_83); let __v_130: G = (__v_92 * __v_84); let __v_131: G = (__v_94 * __v_85); let __v_132: G = (__v_130 + __v_131); let __v_133: G = (__v_129 + __v_132); let __v_134: G = (__v_82 + __v_133); let __v_135: G = (__v_90 * __v_87); let __v_136: G = (__v_92 * __v_88); let __v_137: G = (__v_94 * __v_89); let __v_138: G = (__v_136 + __v_137); let __v_139: G = (__v_135 + __v_138); let __v_140: G = (__v_86 + __v_139); let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_98, __v_104, __v_110, __v_116, __v_122, __v_128, __v_134, __v_140, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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)? }, } } }; break '__mc_0 []; }, _ => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_98, __v_104, __v_110, __v_116, __v_122, __v_128, __v_134, __v_140, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; let __v_144: G = __r_arr[3]; let __v_145: G = __r_arr[4]; let __v_146: G = __r_arr[5]; let __v_147: G = __r_arr[6]; let __v_148: G = __r_arr[7]; let __v_149: G = __r_arr[8]; let __v_150: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_150]; 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_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; let __v_154: G = __r_arr[3]; let __v_155: G = __r_arr[4]; let __v_156: G = __r_arr[5]; let __v_157: G = __r_arr[6]; let __v_158: G = __r_arr[7]; let __v_159: G = __r_arr[8]; let __v_160: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_160]; 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_161: G = __r_arr[0]; let __v_162: G = __r_arr[1]; let __v_163: G = __r_arr[2]; let __v_164: G = __r_arr[3]; let __v_165: G = __r_arr[4]; let __v_166: G = __r_arr[5]; let __v_167: G = __r_arr[6]; let __v_168: G = __r_arr[7]; let __v_169: G = __r_arr[8]; let __v_170: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_170]; 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_171: G = __r_arr[0]; let __v_172: G = __r_arr[1]; let __v_173: G = __r_arr[2]; let __v_174: G = __r_arr[3]; let __v_175: G = __r_arr[4]; let __v_176: G = __r_arr[5]; let __v_177: G = __r_arr[6]; let __v_178: G = __r_arr[7]; let __v_179: G = __r_arr[8]; let __v_180: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_180]; 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_181: G = __r_arr[0]; let __v_182: G = __r_arr[1]; let __v_183: G = __r_arr[2]; let __v_184: G = __r_arr[3]; let __v_185: G = __r_arr[4]; let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; let __v_189: G = __r_arr[8]; let __v_190: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_190]; 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_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __v_193: G = __r_arr[2]; let __v_194: G = __r_arr[3]; let __v_195: G = __r_arr[4]; let __v_196: G = __r_arr[5]; let __v_197: G = __r_arr[6]; let __v_198: G = __r_arr[7]; let __v_199: G = __r_arr[8]; let __v_200: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_200]; 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_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; let __v_203: G = __r_arr[2]; let __v_204: G = __r_arr[3]; let __v_205: G = __r_arr[4]; let __v_206: G = __r_arr[5]; let __v_207: G = __r_arr[6]; let __v_208: G = __r_arr[7]; let __v_209: G = __r_arr[8]; let __v_210: G = __r_arr[9]; let __v_211: G = G::from_u64(0); let __v_212: G = G::from_u64(1); let __v_213: G = { let __values: [G; 10] = [__v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_214: G = { let __values: [G; 10] = [__v_211, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_213]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_215: G = { let __values: [G; 10] = [__v_211, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_214]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_216: G = { let __values: [G; 10] = [__v_211, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_215]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_217: G = { let __values: [G; 10] = [__v_211, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_216]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_218: G = { let __values: [G; 10] = [__v_211, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_217]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_219: G = { let __values: [G; 10] = [__v_211, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_218]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_220: G = { let __values: [G; 10] = [__v_211, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_219]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_210]; 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_221: G = __r_arr[0]; let __v_222: G = __r_arr[1]; let __v_223: G = __r_arr[2]; let __v_224: G = __r_arr[3]; let __v_225: G = __r_arr[4]; let __v_226: G = __r_arr[5]; let __v_227: G = __r_arr[6]; let __v_228: G = __r_arr[7]; let __v_229: G = __r_arr[8]; let __v_230: G = __r_arr[9]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_230, __v_221]; 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_231: G = __r_arr[0]; let __v_232: G = __r_arr[1]; let __v_233: G = __r_arr[2]; let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_233]; 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_234: G = __r_arr[0]; let __v_235: G = __r_arr[1]; let __v_236: G = __r_arr[2]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_236, __v_221]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_237: G = __r_arr[0]; let __v_238: G = __r_arr[1]; let __v_239: G = { let __values: [G; 10] = [__v_211, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_232]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_220, __v_239]; 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_240: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_238.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_241: G = __loaded[0]; let __v_242: G = __loaded[1]; let __v_243: G = __loaded[2]; if (__v_241 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } if (__v_242 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } if (__v_243 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_271] = [__v_141, __v_151, __v_161, __v_171, __v_181, __v_191, __v_201, __v_240, __v_231, __v_234, __v_235, __v_237]; record.function_queries[271].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_17, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_17, __v_18, __v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(103); let __v_22: G = G::from_u64(230); let __v_23: G = G::from_u64(9); let __v_24: G = G::from_u64(106); let __v_25: G = G::from_u64(133); let __v_26: G = G::from_u64(174); let __v_27: G = G::from_u64(187); let __v_28: G = G::from_u64(114); let __v_29: G = G::from_u64(243); let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(60); let __v_32: G = G::from_u64(58); let __v_33: G = G::from_u64(245); let __v_34: G = G::from_u64(79); let __v_35: G = G::from_u64(165); let __v_36: G = G::from_u64(127); let __v_37: G = G::from_u64(82); let __v_38: G = G::from_u64(14); let __v_39: G = G::from_u64(81); let __v_40: G = G::from_u64(140); let __v_41: G = G::from_u64(104); let __v_42: G = G::from_u64(5); let __v_43: G = G::from_u64(155); let __v_44: G = G::from_u64(171); let __v_45: G = G::from_u64(217); let __v_46: G = G::from_u64(131); let __v_47: G = G::from_u64(31); let __v_48: G = G::from_u64(25); let __v_49: G = G::from_u64(205); let __v_50: G = G::from_u64(224); let __v_51: G = G::from_u64(91); let __v_52: G = { let __values: [G; 3] = [__v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_53: G = G::from_u64(0); let __v_54: G = { let __values: [G; 8] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 32] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_21, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 34] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_20, __v_52, __v_53, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; let __v_67: G = __r_arr[9]; let __v_68: G = __r_arr[10]; let __v_69: G = __r_arr[11]; let __v_70: G = __r_arr[12]; let __v_71: G = __r_arr[13]; let __v_72: G = __r_arr[14]; let __v_73: G = __r_arr[15]; let __v_74: G = __r_arr[16]; let __v_75: G = __r_arr[17]; let __v_76: G = __r_arr[18]; let __v_77: G = __r_arr[19]; let __v_78: G = __r_arr[20]; let __v_79: G = __r_arr[21]; let __v_80: G = __r_arr[22]; let __v_81: G = __r_arr[23]; let __v_82: G = __r_arr[24]; let __v_83: G = __r_arr[25]; let __v_84: G = __r_arr[26]; let __v_85: G = __r_arr[27]; let __v_86: G = __r_arr[28]; let __v_87: G = __r_arr[29]; let __v_88: G = __r_arr[30]; let __v_89: G = __r_arr[31]; let __v_90: G = G::from_u64(256); let __v_91: G = __v_90 * __v_59; let __v_92: G = G::from_u64(65536); let __v_93: G = __v_92 * __v_60; let __v_94: G = G::from_u64(16777216); let __v_95: G = __v_94 * __v_61; let __v_96: G = __v_93 + __v_95; let __v_97: G = __v_91 + __v_96; let __v_98: G = __v_58 + __v_97; let __v_99: G = __v_90 * __v_63; let __v_100: G = __v_92 * __v_64; let __v_101: G = __v_94 * __v_65; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_99 + __v_102; let __v_104: G = __v_62 + __v_103; let __v_105: G = __v_90 * __v_67; let __v_106: G = __v_92 * __v_68; let __v_107: G = __v_94 * __v_69; let __v_108: G = __v_106 + __v_107; let __v_109: G = __v_105 + __v_108; let __v_110: G = __v_66 + __v_109; let __v_111: G = __v_90 * __v_71; let __v_112: G = __v_92 * __v_72; let __v_113: G = __v_94 * __v_73; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_111 + __v_114; let __v_116: G = __v_70 + __v_115; let __v_117: G = __v_90 * __v_75; let __v_118: G = __v_92 * __v_76; let __v_119: G = __v_94 * __v_77; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_117 + __v_120; let __v_122: G = __v_74 + __v_121; let __v_123: G = __v_90 * __v_79; let __v_124: G = __v_92 * __v_80; let __v_125: G = __v_94 * __v_81; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_123 + __v_126; let __v_128: G = __v_78 + __v_127; let __v_129: G = __v_90 * __v_83; let __v_130: G = __v_92 * __v_84; let __v_131: G = __v_94 * __v_85; let __v_132: G = __v_130 + __v_131; let __v_133: G = __v_129 + __v_132; let __v_134: G = __v_82 + __v_133; let __v_135: G = __v_90 * __v_87; let __v_136: G = __v_92 * __v_88; let __v_137: G = __v_94 * __v_89; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_135 + __v_138; let __v_140: G = __v_86 + __v_139; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_98, __v_104, __v_110, __v_116, __v_122, __v_128, __v_134, __v_140, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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)? }, } } }; break '__mc_0 []; }, _ => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_98, __v_104, __v_110, __v_116, __v_122, __v_128, __v_134, __v_140, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; let __v_144: G = __r_arr[3]; let __v_145: G = __r_arr[4]; let __v_146: G = __r_arr[5]; let __v_147: G = __r_arr[6]; let __v_148: G = __r_arr[7]; let __v_149: G = __r_arr[8]; let __v_150: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_150]; 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_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; let __v_154: G = __r_arr[3]; let __v_155: G = __r_arr[4]; let __v_156: G = __r_arr[5]; let __v_157: G = __r_arr[6]; let __v_158: G = __r_arr[7]; let __v_159: G = __r_arr[8]; let __v_160: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_160]; 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_161: G = __r_arr[0]; let __v_162: G = __r_arr[1]; let __v_163: G = __r_arr[2]; let __v_164: G = __r_arr[3]; let __v_165: G = __r_arr[4]; let __v_166: G = __r_arr[5]; let __v_167: G = __r_arr[6]; let __v_168: G = __r_arr[7]; let __v_169: G = __r_arr[8]; let __v_170: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_170]; 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_171: G = __r_arr[0]; let __v_172: G = __r_arr[1]; let __v_173: G = __r_arr[2]; let __v_174: G = __r_arr[3]; let __v_175: G = __r_arr[4]; let __v_176: G = __r_arr[5]; let __v_177: G = __r_arr[6]; let __v_178: G = __r_arr[7]; let __v_179: G = __r_arr[8]; let __v_180: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_180]; 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_181: G = __r_arr[0]; let __v_182: G = __r_arr[1]; let __v_183: G = __r_arr[2]; let __v_184: G = __r_arr[3]; let __v_185: G = __r_arr[4]; let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; let __v_189: G = __r_arr[8]; let __v_190: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_190]; 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_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __v_193: G = __r_arr[2]; let __v_194: G = __r_arr[3]; let __v_195: G = __r_arr[4]; let __v_196: G = __r_arr[5]; let __v_197: G = __r_arr[6]; let __v_198: G = __r_arr[7]; let __v_199: G = __r_arr[8]; let __v_200: G = __r_arr[9]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_200]; 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_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; let __v_203: G = __r_arr[2]; let __v_204: G = __r_arr[3]; let __v_205: G = __r_arr[4]; let __v_206: G = __r_arr[5]; let __v_207: G = __r_arr[6]; let __v_208: G = __r_arr[7]; let __v_209: G = __r_arr[8]; let __v_210: G = __r_arr[9]; let __v_211: G = G::from_u64(0); let __v_212: G = G::from_u64(1); let __v_213: G = { let __values: [G; 10] = [__v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_214: G = { let __values: [G; 10] = [__v_211, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_213]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_215: G = { let __values: [G; 10] = [__v_211, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_214]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_216: G = { let __values: [G; 10] = [__v_211, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_215]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_217: G = { let __values: [G; 10] = [__v_211, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_216]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_218: G = { let __values: [G; 10] = [__v_211, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_217]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_219: G = { let __values: [G; 10] = [__v_211, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_218]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_220: G = { let __values: [G; 10] = [__v_211, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_219]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_210]; 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_221: G = __r_arr[0]; let __v_222: G = __r_arr[1]; let __v_223: G = __r_arr[2]; let __v_224: G = __r_arr[3]; let __v_225: G = __r_arr[4]; let __v_226: G = __r_arr[5]; let __v_227: G = __r_arr[6]; let __v_228: G = __r_arr[7]; let __v_229: G = __r_arr[8]; let __v_230: G = __r_arr[9]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_230, __v_221]; 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_231: G = __r_arr[0]; let __v_232: G = __r_arr[1]; let __v_233: G = __r_arr[2]; let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_233]; 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_234: G = __r_arr[0]; let __v_235: G = __r_arr[1]; let __v_236: G = __r_arr[2]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_236, __v_221]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_237: G = __r_arr[0]; let __v_238: G = __r_arr[1]; let __v_239: G = { let __values: [G; 10] = [__v_211, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_232]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_220, __v_239]; 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_240: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_238.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_241: G = __loaded[0]; let __v_242: G = __loaded[1]; let __v_243: G = __loaded[2]; if (__v_241 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } if (__v_242 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } if (__v_243 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_271] = [__v_141, __v_151, __v_161, __v_171, __v_181, __v_191, __v_201, __v_240, __v_231, __v_234, __v_235, __v_237]; record.function_queries[271].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_272: usize = 13; const IN_272: usize = 13; const OUT_272: usize = 1; -fn aiur_fn_272(inp: [G; IN_272], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_14: G = __io_pair.0; let __v_15: G = __io_pair.1; let __v_16: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_16, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_17: G = __io_pair.0; let __v_18: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_16, __v_17, __v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, (&__args[..]))?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_21, __v_20]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = G::from_u64(1); if (__v_24 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_25 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_29, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, (&__args[..]))?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { (*(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65])) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_33, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_37, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, (&__args[..]))?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { (*(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70])) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = (__v_14 + __v_15); if (__v_39 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30, __v_34, __v_38]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_41, __v_22]; 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_42: G = __r_arr[0]; if (__v_42 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_27 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_272] = [__v_22]; record.function_queries[272].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_14: G = __io_pair.0; let __v_15: G = __io_pair.1; let __v_16: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_17: G = __io_pair.0; let __v_18: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_16, __v_17, __v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_21, __v_20]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = G::from_u64(1); if (__v_24 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_25 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_29, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_33, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_37, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __v_14 + __v_15; if (__v_39 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30, __v_34, __v_38]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_41, __v_22]; 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_42: G = __r_arr[0]; if (__v_42 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_27 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_272] = [__v_22]; record.function_queries[272].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_273: usize = 28; const IN_273: usize = 28; const OUT_273: usize = 8; -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 = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __v_39: G = __r_arr[11]; let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_40: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_41, __v_42]; 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_43: G = __r_arr[0]; if (__v_43 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("aggr: child has the wrong claim channel".to_string()) }); } match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_41]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(10); if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: IxVM child must expose a 10-word verify_claim claim".to_string()) }); } let __v_46: G = G::from_u64(1); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_41, __v_46]; 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_47: G = __r_arr[0]; if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: IxVM child has the wrong entrypoint".to_string()) }); } let __v_48: G = G::from_u64(2); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_41, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __ret: [G; OUT_273] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_41]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(18); if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: recursive child must expose an 18-word ix_aggr claim".to_string()) }); } let __v_46: G = G::from_u64(1); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_41, __v_46]; 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_47: G = __r_arr[0]; if (__v_47 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: recursive child has the wrong entrypoint".to_string()) }); } let __v_48: G = G::from_u64(2); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_41, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_57: G = G::from_u64(10); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_41, __v_57]; 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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __ret: [G; OUT_273] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; record.function_queries[273].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __v_39: G = __r_arr[11]; let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_40: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_41, __v_42]; 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_43: G = __r_arr[0]; if (__v_43 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("aggr: child has the wrong claim channel".to_string()) }); } match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_41]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(10); if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: IxVM child must expose a 10-word verify_claim claim".to_string()) }); } let __v_46: G = G::from_u64(1); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_41, __v_46]; 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_47: G = __r_arr[0]; if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: IxVM child has the wrong entrypoint".to_string()) }); } let __v_48: G = G::from_u64(2); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_41, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __ret: [G; OUT_273] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_41]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(18); if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: recursive child must expose an 18-word ix_aggr claim".to_string()) }); } let __v_46: G = G::from_u64(1); let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_41, __v_46]; 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_47: G = __r_arr[0]; if (__v_47 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: recursive child has the wrong entrypoint".to_string()) }); } let __v_48: G = G::from_u64(2); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_41, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_57: G = G::from_u64(10); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_41, __v_57]; 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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __ret: [G; OUT_273] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_274: usize = 35; const IN_274: usize = 35; const OUT_274: usize = 0; -fn aiur_fn_274(inp: [G; IN_274], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = G::from_u64(0); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_269] = { let __args: [G; IN_269] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_274] = []; record.function_queries[274].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_274(inp: [G; IN_274], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = G::from_u64(0); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_269] = { let __args: [G; IN_269] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_274] = []; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_275: usize = 36; const IN_275: usize = 36; const OUT_275: usize = 0; -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]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_266] = { let __args: [G; IN_266] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, (&__args[..]))?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { (*(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266])) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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_58: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_62]; let __info = io_buffer.get_info(__v_62, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_63: G = __io_pair.0; let __v_64: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_62, __v_63, __v_64]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(103); let __v_67: G = G::from_u64(230); let __v_68: G = G::from_u64(9); let __v_69: G = G::from_u64(106); let __v_70: G = G::from_u64(133); let __v_71: G = G::from_u64(174); let __v_72: G = G::from_u64(187); let __v_73: G = G::from_u64(114); let __v_74: G = G::from_u64(243); let __v_75: G = G::from_u64(110); let __v_76: G = G::from_u64(60); let __v_77: G = G::from_u64(58); let __v_78: G = G::from_u64(245); let __v_79: G = G::from_u64(79); let __v_80: G = G::from_u64(165); let __v_81: G = G::from_u64(127); let __v_82: G = G::from_u64(82); let __v_83: G = G::from_u64(14); let __v_84: G = G::from_u64(81); let __v_85: G = G::from_u64(140); let __v_86: G = G::from_u64(104); let __v_87: G = G::from_u64(5); let __v_88: G = G::from_u64(155); let __v_89: G = G::from_u64(171); let __v_90: G = G::from_u64(217); let __v_91: G = G::from_u64(131); let __v_92: G = G::from_u64(31); let __v_93: G = G::from_u64(25); let __v_94: G = G::from_u64(205); let __v_95: G = G::from_u64(224); let __v_96: G = G::from_u64(91); let __v_97: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_98: G = { let __values: [G; 8] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_99: G = { let __values: [G; 32] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_66, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_100: G = { let __values: [G; 34] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_65, __v_97, __v_36, __v_36, __v_98, __v_99, __v_100]; 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_101: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_101]; 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_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = __r_arr[2]; let __v_105: G = __r_arr[3]; let __v_106: G = __r_arr[4]; let __v_107: G = __r_arr[5]; let __v_108: G = __r_arr[6]; let __v_109: G = __r_arr[7]; let __v_110: G = __r_arr[8]; let __v_111: G = __r_arr[9]; let __v_112: G = __r_arr[10]; let __v_113: G = __r_arr[11]; let __v_114: G = __r_arr[12]; let __v_115: G = __r_arr[13]; let __v_116: G = __r_arr[14]; let __v_117: G = __r_arr[15]; let __v_118: G = __r_arr[16]; let __v_119: G = __r_arr[17]; let __v_120: G = __r_arr[18]; let __v_121: G = __r_arr[19]; let __v_122: G = __r_arr[20]; let __v_123: G = __r_arr[21]; let __v_124: G = __r_arr[22]; let __v_125: G = __r_arr[23]; let __v_126: G = __r_arr[24]; let __v_127: G = __r_arr[25]; let __v_128: G = __r_arr[26]; let __v_129: G = __r_arr[27]; let __v_130: G = __r_arr[28]; let __v_131: G = __r_arr[29]; let __v_132: G = __r_arr[30]; let __v_133: G = __r_arr[31]; let __v_134: G = G::from_u64(256); let __v_135: G = (__v_134 * __v_103); let __v_136: G = G::from_u64(65536); let __v_137: G = (__v_136 * __v_104); let __v_138: G = G::from_u64(16777216); let __v_139: G = (__v_138 * __v_105); let __v_140: G = (__v_137 + __v_139); let __v_141: G = (__v_135 + __v_140); let __v_142: G = (__v_102 + __v_141); let __v_143: G = (__v_134 * __v_107); let __v_144: G = (__v_136 * __v_108); let __v_145: G = (__v_138 * __v_109); let __v_146: G = (__v_144 + __v_145); let __v_147: G = (__v_143 + __v_146); let __v_148: G = (__v_106 + __v_147); let __v_149: G = (__v_134 * __v_111); let __v_150: G = (__v_136 * __v_112); let __v_151: G = (__v_138 * __v_113); let __v_152: G = (__v_150 + __v_151); let __v_153: G = (__v_149 + __v_152); let __v_154: G = (__v_110 + __v_153); let __v_155: G = (__v_134 * __v_115); let __v_156: G = (__v_136 * __v_116); let __v_157: G = (__v_138 * __v_117); let __v_158: G = (__v_156 + __v_157); let __v_159: G = (__v_155 + __v_158); let __v_160: G = (__v_114 + __v_159); let __v_161: G = (__v_134 * __v_119); let __v_162: G = (__v_136 * __v_120); let __v_163: G = (__v_138 * __v_121); let __v_164: G = (__v_162 + __v_163); let __v_165: G = (__v_161 + __v_164); let __v_166: G = (__v_118 + __v_165); let __v_167: G = (__v_134 * __v_123); let __v_168: G = (__v_136 * __v_124); let __v_169: G = (__v_138 * __v_125); let __v_170: G = (__v_168 + __v_169); let __v_171: G = (__v_167 + __v_170); let __v_172: G = (__v_122 + __v_171); let __v_173: G = (__v_134 * __v_127); let __v_174: G = (__v_136 * __v_128); let __v_175: G = (__v_138 * __v_129); let __v_176: G = (__v_174 + __v_175); let __v_177: G = (__v_173 + __v_176); let __v_178: G = (__v_126 + __v_177); let __v_179: G = (__v_134 * __v_131); let __v_180: G = (__v_136 * __v_132); let __v_181: G = (__v_138 * __v_133); let __v_182: G = (__v_180 + __v_181); let __v_183: G = (__v_179 + __v_182); let __v_184: G = (__v_130 + __v_183); if (__v_142 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_142.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_148 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_154 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_160 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_166 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_172 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_178 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_184 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_65]; 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_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_55]; 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_188: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_59]; 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_189: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_56, __v_57]; 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_190: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_60, __v_61]; 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_191: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_185]; 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_192: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_186, __v_187]; 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_193: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_188, __v_189, __v_192]; 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 __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, (&__args[..]))?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { (*(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260])) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_275] = []; record.function_queries[275].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_266] = { let __args: [G; IN_266] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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_58: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_62]; let __info = io_buffer.get_info(__v_62, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_63: G = __io_pair.0; let __v_64: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_62, __v_63, __v_64]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(103); let __v_67: G = G::from_u64(230); let __v_68: G = G::from_u64(9); let __v_69: G = G::from_u64(106); let __v_70: G = G::from_u64(133); let __v_71: G = G::from_u64(174); let __v_72: G = G::from_u64(187); let __v_73: G = G::from_u64(114); let __v_74: G = G::from_u64(243); let __v_75: G = G::from_u64(110); let __v_76: G = G::from_u64(60); let __v_77: G = G::from_u64(58); let __v_78: G = G::from_u64(245); let __v_79: G = G::from_u64(79); let __v_80: G = G::from_u64(165); let __v_81: G = G::from_u64(127); let __v_82: G = G::from_u64(82); let __v_83: G = G::from_u64(14); let __v_84: G = G::from_u64(81); let __v_85: G = G::from_u64(140); let __v_86: G = G::from_u64(104); let __v_87: G = G::from_u64(5); let __v_88: G = G::from_u64(155); let __v_89: G = G::from_u64(171); let __v_90: G = G::from_u64(217); let __v_91: G = G::from_u64(131); let __v_92: G = G::from_u64(31); let __v_93: G = G::from_u64(25); let __v_94: G = G::from_u64(205); let __v_95: G = G::from_u64(224); let __v_96: G = G::from_u64(91); let __v_97: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_98: G = { let __values: [G; 8] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_99: G = { let __values: [G; 32] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_66, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_100: G = { let __values: [G; 34] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_65, __v_97, __v_36, __v_36, __v_98, __v_99, __v_100]; 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_101: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_101]; 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_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = __r_arr[2]; let __v_105: G = __r_arr[3]; let __v_106: G = __r_arr[4]; let __v_107: G = __r_arr[5]; let __v_108: G = __r_arr[6]; let __v_109: G = __r_arr[7]; let __v_110: G = __r_arr[8]; let __v_111: G = __r_arr[9]; let __v_112: G = __r_arr[10]; let __v_113: G = __r_arr[11]; let __v_114: G = __r_arr[12]; let __v_115: G = __r_arr[13]; let __v_116: G = __r_arr[14]; let __v_117: G = __r_arr[15]; let __v_118: G = __r_arr[16]; let __v_119: G = __r_arr[17]; let __v_120: G = __r_arr[18]; let __v_121: G = __r_arr[19]; let __v_122: G = __r_arr[20]; let __v_123: G = __r_arr[21]; let __v_124: G = __r_arr[22]; let __v_125: G = __r_arr[23]; let __v_126: G = __r_arr[24]; let __v_127: G = __r_arr[25]; let __v_128: G = __r_arr[26]; let __v_129: G = __r_arr[27]; let __v_130: G = __r_arr[28]; let __v_131: G = __r_arr[29]; let __v_132: G = __r_arr[30]; let __v_133: G = __r_arr[31]; let __v_134: G = G::from_u64(256); let __v_135: G = __v_134 * __v_103; let __v_136: G = G::from_u64(65536); let __v_137: G = __v_136 * __v_104; let __v_138: G = G::from_u64(16777216); let __v_139: G = __v_138 * __v_105; let __v_140: G = __v_137 + __v_139; let __v_141: G = __v_135 + __v_140; let __v_142: G = __v_102 + __v_141; let __v_143: G = __v_134 * __v_107; let __v_144: G = __v_136 * __v_108; let __v_145: G = __v_138 * __v_109; let __v_146: G = __v_144 + __v_145; let __v_147: G = __v_143 + __v_146; let __v_148: G = __v_106 + __v_147; let __v_149: G = __v_134 * __v_111; let __v_150: G = __v_136 * __v_112; let __v_151: G = __v_138 * __v_113; let __v_152: G = __v_150 + __v_151; let __v_153: G = __v_149 + __v_152; let __v_154: G = __v_110 + __v_153; let __v_155: G = __v_134 * __v_115; let __v_156: G = __v_136 * __v_116; let __v_157: G = __v_138 * __v_117; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_155 + __v_158; let __v_160: G = __v_114 + __v_159; let __v_161: G = __v_134 * __v_119; let __v_162: G = __v_136 * __v_120; let __v_163: G = __v_138 * __v_121; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_161 + __v_164; let __v_166: G = __v_118 + __v_165; let __v_167: G = __v_134 * __v_123; let __v_168: G = __v_136 * __v_124; let __v_169: G = __v_138 * __v_125; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_167 + __v_170; let __v_172: G = __v_122 + __v_171; let __v_173: G = __v_134 * __v_127; let __v_174: G = __v_136 * __v_128; let __v_175: G = __v_138 * __v_129; let __v_176: G = __v_174 + __v_175; let __v_177: G = __v_173 + __v_176; let __v_178: G = __v_126 + __v_177; let __v_179: G = __v_134 * __v_131; let __v_180: G = __v_136 * __v_132; let __v_181: G = __v_138 * __v_133; let __v_182: G = __v_180 + __v_181; let __v_183: G = __v_179 + __v_182; let __v_184: G = __v_130 + __v_183; if (__v_142 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_142.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_148 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_154 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_160 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_166 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_172 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_178 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_184 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_65]; 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_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_55]; 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_188: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_59]; 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_189: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_56, __v_57]; 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_190: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_60, __v_61]; 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_191: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_185]; 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_192: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_186, __v_187]; 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_193: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_188, __v_189, __v_192]; 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 __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_275] = []; record.function_queries[275].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_276: usize = 36; const IN_276: usize = 36; const OUT_276: usize = 0; -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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_266] = { let __args: [G; IN_266] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, (&__args[..]))?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { (*(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266])) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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_58: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_62]; let __info = io_buffer.get_info(__v_62, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_63: G = __io_pair.0; let __v_64: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_62, __v_63, __v_64]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(103); let __v_67: G = G::from_u64(230); let __v_68: G = G::from_u64(9); let __v_69: G = G::from_u64(106); let __v_70: G = G::from_u64(133); let __v_71: G = G::from_u64(174); let __v_72: G = G::from_u64(187); let __v_73: G = G::from_u64(114); let __v_74: G = G::from_u64(243); let __v_75: G = G::from_u64(110); let __v_76: G = G::from_u64(60); let __v_77: G = G::from_u64(58); let __v_78: G = G::from_u64(245); let __v_79: G = G::from_u64(79); let __v_80: G = G::from_u64(165); let __v_81: G = G::from_u64(127); let __v_82: G = G::from_u64(82); let __v_83: G = G::from_u64(14); let __v_84: G = G::from_u64(81); let __v_85: G = G::from_u64(140); let __v_86: G = G::from_u64(104); let __v_87: G = G::from_u64(5); let __v_88: G = G::from_u64(155); let __v_89: G = G::from_u64(171); let __v_90: G = G::from_u64(217); let __v_91: G = G::from_u64(131); let __v_92: G = G::from_u64(31); let __v_93: G = G::from_u64(25); let __v_94: G = G::from_u64(205); let __v_95: G = G::from_u64(224); let __v_96: G = G::from_u64(91); let __v_97: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_98: G = { let __values: [G; 8] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_99: G = { let __values: [G; 32] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_66, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_100: G = { let __values: [G; 34] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_65, __v_97, __v_36, __v_36, __v_98, __v_99, __v_100]; 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_101: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_101]; 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_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = __r_arr[2]; let __v_105: G = __r_arr[3]; let __v_106: G = __r_arr[4]; let __v_107: G = __r_arr[5]; let __v_108: G = __r_arr[6]; let __v_109: G = __r_arr[7]; let __v_110: G = __r_arr[8]; let __v_111: G = __r_arr[9]; let __v_112: G = __r_arr[10]; let __v_113: G = __r_arr[11]; let __v_114: G = __r_arr[12]; let __v_115: G = __r_arr[13]; let __v_116: G = __r_arr[14]; let __v_117: G = __r_arr[15]; let __v_118: G = __r_arr[16]; let __v_119: G = __r_arr[17]; let __v_120: G = __r_arr[18]; let __v_121: G = __r_arr[19]; let __v_122: G = __r_arr[20]; let __v_123: G = __r_arr[21]; let __v_124: G = __r_arr[22]; let __v_125: G = __r_arr[23]; let __v_126: G = __r_arr[24]; let __v_127: G = __r_arr[25]; let __v_128: G = __r_arr[26]; let __v_129: G = __r_arr[27]; let __v_130: G = __r_arr[28]; let __v_131: G = __r_arr[29]; let __v_132: G = __r_arr[30]; let __v_133: G = __r_arr[31]; let __v_134: G = G::from_u64(256); let __v_135: G = (__v_134 * __v_103); let __v_136: G = G::from_u64(65536); let __v_137: G = (__v_136 * __v_104); let __v_138: G = G::from_u64(16777216); let __v_139: G = (__v_138 * __v_105); let __v_140: G = (__v_137 + __v_139); let __v_141: G = (__v_135 + __v_140); let __v_142: G = (__v_102 + __v_141); let __v_143: G = (__v_134 * __v_107); let __v_144: G = (__v_136 * __v_108); let __v_145: G = (__v_138 * __v_109); let __v_146: G = (__v_144 + __v_145); let __v_147: G = (__v_143 + __v_146); let __v_148: G = (__v_106 + __v_147); let __v_149: G = (__v_134 * __v_111); let __v_150: G = (__v_136 * __v_112); let __v_151: G = (__v_138 * __v_113); let __v_152: G = (__v_150 + __v_151); let __v_153: G = (__v_149 + __v_152); let __v_154: G = (__v_110 + __v_153); let __v_155: G = (__v_134 * __v_115); let __v_156: G = (__v_136 * __v_116); let __v_157: G = (__v_138 * __v_117); let __v_158: G = (__v_156 + __v_157); let __v_159: G = (__v_155 + __v_158); let __v_160: G = (__v_114 + __v_159); let __v_161: G = (__v_134 * __v_119); let __v_162: G = (__v_136 * __v_120); let __v_163: G = (__v_138 * __v_121); let __v_164: G = (__v_162 + __v_163); let __v_165: G = (__v_161 + __v_164); let __v_166: G = (__v_118 + __v_165); let __v_167: G = (__v_134 * __v_123); let __v_168: G = (__v_136 * __v_124); let __v_169: G = (__v_138 * __v_125); let __v_170: G = (__v_168 + __v_169); let __v_171: G = (__v_167 + __v_170); let __v_172: G = (__v_122 + __v_171); let __v_173: G = (__v_134 * __v_127); let __v_174: G = (__v_136 * __v_128); let __v_175: G = (__v_138 * __v_129); let __v_176: G = (__v_174 + __v_175); let __v_177: G = (__v_173 + __v_176); let __v_178: G = (__v_126 + __v_177); let __v_179: G = (__v_134 * __v_131); let __v_180: G = (__v_136 * __v_132); let __v_181: G = (__v_138 * __v_133); let __v_182: G = (__v_180 + __v_181); let __v_183: G = (__v_179 + __v_182); let __v_184: G = (__v_130 + __v_183); if (__v_142 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_142.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_148 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_154 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_160 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_166 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_172 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_178 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_184 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_65]; 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_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_55, __v_59]; 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_188: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_185, __v_188]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; if (__v_189 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr structural: output subject root is not nodeHash(left, right)".to_string()) }); } let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_56, __v_57]; 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_190: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_60, __v_61]; 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_191: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_186, __v_187]; 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_192: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_190, __v_191, __v_185, __v_192]; 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 __ret: [G; OUT_276] = []; record.function_queries[276].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_266] = { let __args: [G; IN_266] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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_58: G = __r_arr[0]; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_62]; let __info = io_buffer.get_info(__v_62, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_63: G = __io_pair.0; let __v_64: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_62, __v_63, __v_64]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(103); let __v_67: G = G::from_u64(230); let __v_68: G = G::from_u64(9); let __v_69: G = G::from_u64(106); let __v_70: G = G::from_u64(133); let __v_71: G = G::from_u64(174); let __v_72: G = G::from_u64(187); let __v_73: G = G::from_u64(114); let __v_74: G = G::from_u64(243); let __v_75: G = G::from_u64(110); let __v_76: G = G::from_u64(60); let __v_77: G = G::from_u64(58); let __v_78: G = G::from_u64(245); let __v_79: G = G::from_u64(79); let __v_80: G = G::from_u64(165); let __v_81: G = G::from_u64(127); let __v_82: G = G::from_u64(82); let __v_83: G = G::from_u64(14); let __v_84: G = G::from_u64(81); let __v_85: G = G::from_u64(140); let __v_86: G = G::from_u64(104); let __v_87: G = G::from_u64(5); let __v_88: G = G::from_u64(155); let __v_89: G = G::from_u64(171); let __v_90: G = G::from_u64(217); let __v_91: G = G::from_u64(131); let __v_92: G = G::from_u64(31); let __v_93: G = G::from_u64(25); let __v_94: G = G::from_u64(205); let __v_95: G = G::from_u64(224); let __v_96: G = G::from_u64(91); let __v_97: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_98: G = { let __values: [G; 8] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_99: G = { let __values: [G; 32] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_66, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_100: G = { let __values: [G; 34] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_65, __v_97, __v_36, __v_36, __v_98, __v_99, __v_100]; 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_101: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_101]; 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_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = __r_arr[2]; let __v_105: G = __r_arr[3]; let __v_106: G = __r_arr[4]; let __v_107: G = __r_arr[5]; let __v_108: G = __r_arr[6]; let __v_109: G = __r_arr[7]; let __v_110: G = __r_arr[8]; let __v_111: G = __r_arr[9]; let __v_112: G = __r_arr[10]; let __v_113: G = __r_arr[11]; let __v_114: G = __r_arr[12]; let __v_115: G = __r_arr[13]; let __v_116: G = __r_arr[14]; let __v_117: G = __r_arr[15]; let __v_118: G = __r_arr[16]; let __v_119: G = __r_arr[17]; let __v_120: G = __r_arr[18]; let __v_121: G = __r_arr[19]; let __v_122: G = __r_arr[20]; let __v_123: G = __r_arr[21]; let __v_124: G = __r_arr[22]; let __v_125: G = __r_arr[23]; let __v_126: G = __r_arr[24]; let __v_127: G = __r_arr[25]; let __v_128: G = __r_arr[26]; let __v_129: G = __r_arr[27]; let __v_130: G = __r_arr[28]; let __v_131: G = __r_arr[29]; let __v_132: G = __r_arr[30]; let __v_133: G = __r_arr[31]; let __v_134: G = G::from_u64(256); let __v_135: G = __v_134 * __v_103; let __v_136: G = G::from_u64(65536); let __v_137: G = __v_136 * __v_104; let __v_138: G = G::from_u64(16777216); let __v_139: G = __v_138 * __v_105; let __v_140: G = __v_137 + __v_139; let __v_141: G = __v_135 + __v_140; let __v_142: G = __v_102 + __v_141; let __v_143: G = __v_134 * __v_107; let __v_144: G = __v_136 * __v_108; let __v_145: G = __v_138 * __v_109; let __v_146: G = __v_144 + __v_145; let __v_147: G = __v_143 + __v_146; let __v_148: G = __v_106 + __v_147; let __v_149: G = __v_134 * __v_111; let __v_150: G = __v_136 * __v_112; let __v_151: G = __v_138 * __v_113; let __v_152: G = __v_150 + __v_151; let __v_153: G = __v_149 + __v_152; let __v_154: G = __v_110 + __v_153; let __v_155: G = __v_134 * __v_115; let __v_156: G = __v_136 * __v_116; let __v_157: G = __v_138 * __v_117; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_155 + __v_158; let __v_160: G = __v_114 + __v_159; let __v_161: G = __v_134 * __v_119; let __v_162: G = __v_136 * __v_120; let __v_163: G = __v_138 * __v_121; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_161 + __v_164; let __v_166: G = __v_118 + __v_165; let __v_167: G = __v_134 * __v_123; let __v_168: G = __v_136 * __v_124; let __v_169: G = __v_138 * __v_125; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_167 + __v_170; let __v_172: G = __v_122 + __v_171; let __v_173: G = __v_134 * __v_127; let __v_174: G = __v_136 * __v_128; let __v_175: G = __v_138 * __v_129; let __v_176: G = __v_174 + __v_175; let __v_177: G = __v_173 + __v_176; let __v_178: G = __v_126 + __v_177; let __v_179: G = __v_134 * __v_131; let __v_180: G = __v_136 * __v_132; let __v_181: G = __v_138 * __v_133; let __v_182: G = __v_180 + __v_181; let __v_183: G = __v_179 + __v_182; let __v_184: G = __v_130 + __v_183; if (__v_142 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_142.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_148 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_154 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_160 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_166 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_172 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_178 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_184 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_65]; 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_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_55, __v_59]; 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_188: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_185, __v_188]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; if (__v_189 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr structural: output subject root is not nodeHash(left, right)".to_string()) }); } let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_56, __v_57]; 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_190: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_60, __v_61]; 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_191: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_186, __v_187]; 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_192: G = __r_arr[0]; let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_190, __v_191, __v_185, __v_192]; 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 __ret: [G; OUT_276] = []; record.function_queries[276].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_277: usize = 1; const IN_277: usize = 1; const OUT_277: usize = 19; -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 __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(82); if (__v_1 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr range: statement has the wrong tag".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; let __v_73: G = G::from_u64(1); if (__v_70 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } if (__v_71 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } let __v_74: G = G::from_u64(256); let __v_75: G = (__v_74 * __v_40); let __v_76: G = G::from_u64(65536); let __v_77: G = (__v_76 * __v_42); let __v_78: G = G::from_u64(16777216); let __v_79: G = (__v_78 * __v_44); let __v_80: G = G::from_u64(4294967296); let __v_81: G = (__v_80 * __v_46); let __v_82: G = G::from_u64(1099511627776); let __v_83: G = (__v_82 * __v_48); let __v_84: G = G::from_u64(281474976710656); let __v_85: G = (__v_84 * __v_50); let __v_86: G = G::from_u64(72057594037927936); let __v_87: G = (__v_86 * __v_52); let __v_88: G = (__v_85 + __v_87); let __v_89: G = (__v_83 + __v_88); let __v_90: G = (__v_81 + __v_89); let __v_91: G = (__v_79 + __v_90); let __v_92: G = (__v_77 + __v_91); let __v_93: G = (__v_75 + __v_92); let __v_94: G = (__v_38 + __v_93); let __v_95: G = (__v_74 * __v_56); let __v_96: G = (__v_76 * __v_58); let __v_97: G = (__v_78 * __v_60); let __v_98: G = (__v_80 * __v_62); let __v_99: G = (__v_82 * __v_64); let __v_100: G = (__v_84 * __v_66); let __v_101: G = (__v_86 * __v_68); let __v_102: G = (__v_100 + __v_101); let __v_103: G = (__v_99 + __v_102); let __v_104: G = (__v_98 + __v_103); let __v_105: G = (__v_97 + __v_104); let __v_106: G = (__v_96 + __v_105); let __v_107: G = (__v_95 + __v_106); let __v_108: G = (__v_54 + __v_107); let __ret: [G; OUT_277] = [__v_4, __v_6, __v_8, __v_10, __v_12, __v_14, __v_16, __v_18, __v_20, __v_22, __v_24, __v_26, __v_28, __v_30, __v_32, __v_34, __v_36, __v_94, __v_108]; record.function_queries[277].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __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(82); if (__v_1 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr range: statement has the wrong tag".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; let __v_73: G = G::from_u64(1); if (__v_70 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } if (__v_71 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } let __v_74: G = G::from_u64(256); let __v_75: G = __v_74 * __v_40; let __v_76: G = G::from_u64(65536); let __v_77: G = __v_76 * __v_42; let __v_78: G = G::from_u64(16777216); let __v_79: G = __v_78 * __v_44; let __v_80: G = G::from_u64(4294967296); let __v_81: G = __v_80 * __v_46; let __v_82: G = G::from_u64(1099511627776); let __v_83: G = __v_82 * __v_48; let __v_84: G = G::from_u64(281474976710656); let __v_85: G = __v_84 * __v_50; let __v_86: G = G::from_u64(72057594037927936); let __v_87: G = __v_86 * __v_52; let __v_88: G = __v_85 + __v_87; let __v_89: G = __v_83 + __v_88; let __v_90: G = __v_81 + __v_89; let __v_91: G = __v_79 + __v_90; let __v_92: G = __v_77 + __v_91; let __v_93: G = __v_75 + __v_92; let __v_94: G = __v_38 + __v_93; let __v_95: G = __v_74 * __v_56; let __v_96: G = __v_76 * __v_58; let __v_97: G = __v_78 * __v_60; let __v_98: G = __v_80 * __v_62; let __v_99: G = __v_82 * __v_64; let __v_100: G = __v_84 * __v_66; let __v_101: G = __v_86 * __v_68; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_99 + __v_102; let __v_104: G = __v_98 + __v_103; let __v_105: G = __v_97 + __v_104; let __v_106: G = __v_96 + __v_105; let __v_107: G = __v_95 + __v_106; let __v_108: G = __v_54 + __v_107; let __ret: [G; OUT_277] = [__v_4, __v_6, __v_8, __v_10, __v_12, __v_14, __v_16, __v_18, __v_20, __v_22, __v_24, __v_26, __v_28, __v_30, __v_32, __v_34, __v_36, __v_94, __v_108]; record.function_queries[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 = 2; -fn aiur_fn_278(inp: [G; IN_278], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_278] = [__v_65, __v_64]; record.function_queries[278].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_278] = [__v_65, __v_64]; record.function_queries[278].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_279: usize = 2; const IN_279: usize = 2; const OUT_279: usize = 2; -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 __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_279] = [__v_3, __v_0]; record.function_queries[279].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; 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 = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, (&__args[..]))?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { (*(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279])) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_279] = [__v_9, __v_7]; record.function_queries[279].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_279] = [__v_3, __v_0]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; 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 = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_279] = [__v_9, __v_7]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_280: usize = 2; const IN_280: usize = 2; const OUT_280: usize = 2; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_280] = [__v_3, __v_0]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_280] = [__v_9, __v_7]; record.function_queries[280].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_280] = [__v_3, __v_0]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_280] = [__v_9, __v_7]; 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 = 5; -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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __v_16: G = __r_arr[3]; let __v_17: G = __r_arr[4]; let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; let __v_21: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_21, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, (&__args[..]))?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { (*(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279])) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_33, __v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, (&__args[..]))?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_38, __v_37]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __ret: [G; OUT_281] = [__v_11, __v_23, __v_35, __v_39, __v_40]; record.function_queries[281].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __v_16: G = __r_arr[3]; let __v_17: G = __r_arr[4]; let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; let __v_21: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_21, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_33, __v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_38, __v_37]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __ret: [G; OUT_281] = [__v_11, __v_23, __v_35, __v_39, __v_40]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_282: usize = 2; const IN_282: usize = 2; const OUT_282: usize = 2; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_282] = [__v_3, __v_0]; record.function_queries[282].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_6, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_282] = [__v_12, __v_10]; record.function_queries[282].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_282] = [__v_3, __v_0]; record.function_queries[282].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_6, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_282] = [__v_12, __v_10]; record.function_queries[282].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_283: usize = 1; const IN_283: usize = 1; const OUT_283: usize = 10; -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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, (&__args[..]))?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_283] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_20]; record.function_queries[283].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_283] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_20]; record.function_queries[283].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_284: usize = 2; const IN_284: usize = 2; const OUT_284: usize = 2; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_284] = [__v_3, __v_0]; record.function_queries[284].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_11, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 11] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_14]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_284] = [__v_17, __v_15]; record.function_queries[284].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_284] = [__v_3, __v_0]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1); let __v_13: G = __v_1 - __v_12; let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_11, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 11] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_14]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_284] = [__v_17, __v_15]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_285: usize = 2; const IN_285: usize = 2; const OUT_285: usize = 2; -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 = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_2, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_3: G = __io_pair.0; let __v_4: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_2, __v_3, __v_4]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: preamble does not hash to the statement's batch digest".to_string()) }); } let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_17, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, (&__args[..]))?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_29, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; if (__v_33 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } if (__v_34 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } if (__v_35 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } let __ret: [G; OUT_285] = [__v_19, __v_31]; record.function_queries[285].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_2, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_3: G = __io_pair.0; let __v_4: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_2, __v_3, __v_4]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: preamble does not hash to the statement's batch digest".to_string()) }); } let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_17, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_29, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; if (__v_33 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } if (__v_34 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } if (__v_35 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } let __ret: [G; OUT_285] = [__v_19, __v_31]; 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 = 5; -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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_15]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_14: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_7, __v_14, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, (&__args[..]))?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { (*(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216])) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __ret: [G; OUT_286] = [__v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[286].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_15]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_14: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_7, __v_14, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, &__args[..])?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __ret: [G; OUT_286] = [__v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[286].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_287: usize = 23; const IN_287: usize = 23; const OUT_287: usize = 3; -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]; match __v_15.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_287] = [__v_21, __v_22, __v_13]; record.function_queries[287].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; let __v_26: G = __loaded[3]; let __v_27: G = __loaded[4]; let __v_28: G = __loaded[5]; match __v_23.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, (&__args[..]))?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { (*(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62])) }; __ret }, _ => { aiur_fn_62::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = __r_arr[9]; let __v_39: G = __r_arr[10]; let __v_40: G = __r_arr[11]; let __v_41: G = __r_arr[12]; let __v_42: G = __r_arr[13]; let __v_43: G = __r_arr[14]; let __v_44: G = __r_arr[15]; let __v_45: G = __r_arr[16]; let __v_46: G = __r_arr[17]; let __v_47: G = __r_arr[18]; let __v_48: G = __r_arr[19]; let __v_49: G = __r_arr[20]; let __v_50: G = __r_arr[21]; let __v_51: G = __r_arr[22]; let __v_52: G = __r_arr[23]; let __v_53: G = __r_arr[24]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, (&__args[..]))?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { (*(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232])) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_14 + __v_56); let __v_58: G = (__v_15 - __v_56); let __v_59: G = (__v_21 + __v_54); let __v_60: G = (__v_22 + __v_55); let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_28, __v_53, __v_57, __v_58, __v_16, __v_17, __v_18, __v_19, __v_20, __v_59, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __ret: [G; OUT_287] = [__v_61, __v_62, __v_63]; record.function_queries[287].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }) } +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]; match __v_15.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_287] = [__v_21, __v_22, __v_13]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; let __v_26: G = __loaded[3]; let __v_27: G = __loaded[4]; let __v_28: G = __loaded[5]; match __v_23.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, &__args[..])?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => { aiur_fn_62::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = __r_arr[9]; let __v_39: G = __r_arr[10]; let __v_40: G = __r_arr[11]; let __v_41: G = __r_arr[12]; let __v_42: G = __r_arr[13]; let __v_43: G = __r_arr[14]; let __v_44: G = __r_arr[15]; let __v_45: G = __r_arr[16]; let __v_46: G = __r_arr[17]; let __v_47: G = __r_arr[18]; let __v_48: G = __r_arr[19]; let __v_49: G = __r_arr[20]; let __v_50: G = __r_arr[21]; let __v_51: G = __r_arr[22]; let __v_52: G = __r_arr[23]; let __v_53: G = __r_arr[24]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, &__args[..])?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = __v_14 + __v_56; let __v_58: G = __v_15 - __v_56; let __v_59: G = __v_21 + __v_54; let __v_60: G = __v_22 + __v_55; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_28, __v_53, __v_57, __v_58, __v_16, __v_17, __v_18, __v_19, __v_20, __v_59, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __ret: [G; OUT_287] = [__v_61, __v_62, __v_63]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_288: usize = 8; const IN_288: usize = 8; const OUT_288: usize = 19; -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 __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_8]; let __info = io_buffer.get_info(__v_8, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_8, __v_9, __v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 8] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_47: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_48: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_44, __v_45, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = G::from_u64(256); let __v_83: G = (__v_82 * __v_51); let __v_84: G = G::from_u64(65536); let __v_85: G = (__v_84 * __v_52); let __v_86: G = G::from_u64(16777216); let __v_87: G = (__v_86 * __v_53); let __v_88: G = (__v_85 + __v_87); let __v_89: G = (__v_83 + __v_88); let __v_90: G = (__v_50 + __v_89); let __v_91: G = (__v_82 * __v_55); let __v_92: G = (__v_84 * __v_56); let __v_93: G = (__v_86 * __v_57); let __v_94: G = (__v_92 + __v_93); let __v_95: G = (__v_91 + __v_94); let __v_96: G = (__v_54 + __v_95); let __v_97: G = (__v_82 * __v_59); let __v_98: G = (__v_84 * __v_60); let __v_99: G = (__v_86 * __v_61); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_97 + __v_100); let __v_102: G = (__v_58 + __v_101); let __v_103: G = (__v_82 * __v_63); let __v_104: G = (__v_84 * __v_64); let __v_105: G = (__v_86 * __v_65); let __v_106: G = (__v_104 + __v_105); let __v_107: G = (__v_103 + __v_106); let __v_108: G = (__v_62 + __v_107); let __v_109: G = (__v_82 * __v_67); let __v_110: G = (__v_84 * __v_68); let __v_111: G = (__v_86 * __v_69); let __v_112: G = (__v_110 + __v_111); let __v_113: G = (__v_109 + __v_112); let __v_114: G = (__v_66 + __v_113); let __v_115: G = (__v_82 * __v_71); let __v_116: G = (__v_84 * __v_72); let __v_117: G = (__v_86 * __v_73); let __v_118: G = (__v_116 + __v_117); let __v_119: G = (__v_115 + __v_118); let __v_120: G = (__v_70 + __v_119); let __v_121: G = (__v_82 * __v_75); let __v_122: G = (__v_84 * __v_76); let __v_123: G = (__v_86 * __v_77); let __v_124: G = (__v_122 + __v_123); let __v_125: G = (__v_121 + __v_124); let __v_126: G = (__v_74 + __v_125); let __v_127: G = (__v_82 * __v_79); let __v_128: G = (__v_84 * __v_80); let __v_129: G = (__v_86 * __v_81); let __v_130: G = (__v_128 + __v_129); let __v_131: G = (__v_127 + __v_130); let __v_132: G = (__v_78 + __v_131); if (__v_90 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_96 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_108 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_114 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_120 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_126 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_132 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } let __r_arr: [G; OUT_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_133: G = __r_arr[0]; let __v_134: G = __r_arr[1]; let __v_135: G = __r_arr[2]; let __v_136: G = __r_arr[3]; let __v_137: G = __r_arr[4]; let __v_138: G = __r_arr[5]; let __v_139: G = __r_arr[6]; let __v_140: G = __r_arr[7]; let __v_141: G = __r_arr[8]; let __v_142: G = __r_arr[9]; let __v_143: G = __r_arr[10]; let __v_144: G = __r_arr[11]; let __v_145: G = __r_arr[12]; let __v_146: G = __r_arr[13]; let __v_147: G = __r_arr[14]; let __v_148: G = __r_arr[15]; let __v_149: G = __r_arr[16]; let __v_150: G = __r_arr[17]; let __v_151: G = __r_arr[18]; let __ret: [G; OUT_288] = [__v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151]; record.function_queries[288].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_8]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_8, __v_9, __v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 8] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_47: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_48: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_44, __v_45, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_51; let __v_84: G = G::from_u64(65536); let __v_85: G = __v_84 * __v_52; let __v_86: G = G::from_u64(16777216); let __v_87: G = __v_86 * __v_53; let __v_88: G = __v_85 + __v_87; let __v_89: G = __v_83 + __v_88; let __v_90: G = __v_50 + __v_89; let __v_91: G = __v_82 * __v_55; let __v_92: G = __v_84 * __v_56; let __v_93: G = __v_86 * __v_57; let __v_94: G = __v_92 + __v_93; let __v_95: G = __v_91 + __v_94; let __v_96: G = __v_54 + __v_95; let __v_97: G = __v_82 * __v_59; let __v_98: G = __v_84 * __v_60; let __v_99: G = __v_86 * __v_61; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_97 + __v_100; let __v_102: G = __v_58 + __v_101; let __v_103: G = __v_82 * __v_63; let __v_104: G = __v_84 * __v_64; let __v_105: G = __v_86 * __v_65; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_103 + __v_106; let __v_108: G = __v_62 + __v_107; let __v_109: G = __v_82 * __v_67; let __v_110: G = __v_84 * __v_68; let __v_111: G = __v_86 * __v_69; let __v_112: G = __v_110 + __v_111; let __v_113: G = __v_109 + __v_112; let __v_114: G = __v_66 + __v_113; let __v_115: G = __v_82 * __v_71; let __v_116: G = __v_84 * __v_72; let __v_117: G = __v_86 * __v_73; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_115 + __v_118; let __v_120: G = __v_70 + __v_119; let __v_121: G = __v_82 * __v_75; let __v_122: G = __v_84 * __v_76; let __v_123: G = __v_86 * __v_77; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_121 + __v_124; let __v_126: G = __v_74 + __v_125; let __v_127: G = __v_82 * __v_79; let __v_128: G = __v_84 * __v_80; let __v_129: G = __v_86 * __v_81; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_127 + __v_130; let __v_132: G = __v_78 + __v_131; if (__v_90 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_96 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_108 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_114 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_120 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_126 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_132 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } let __r_arr: [G; OUT_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_133: G = __r_arr[0]; let __v_134: G = __r_arr[1]; let __v_135: G = __r_arr[2]; let __v_136: G = __r_arr[3]; let __v_137: G = __r_arr[4]; let __v_138: G = __r_arr[5]; let __v_139: G = __r_arr[6]; let __v_140: G = __r_arr[7]; let __v_141: G = __r_arr[8]; let __v_142: G = __r_arr[9]; let __v_143: G = __r_arr[10]; let __v_144: G = __r_arr[11]; let __v_145: G = __r_arr[12]; let __v_146: G = __r_arr[13]; let __v_147: G = __r_arr[14]; let __v_148: G = __r_arr[15]; let __v_149: G = __r_arr[16]; let __v_150: G = __r_arr[17]; let __v_151: G = __r_arr[18]; let __ret: [G; OUT_288] = [__v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_289: usize = 27; const IN_289: usize = 27; const OUT_289: usize = 19; -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 = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_27, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_266] = { let __args: [G; IN_266] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; 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 __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __ret: [G; OUT_289] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; record.function_queries[289].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_27, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_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_266] = { let __args: [G; IN_266] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; 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 __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __ret: [G; OUT_289] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; record.function_queries[289].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_290: usize = 24; const IN_290: usize = 24; const OUT_290: usize = 0; -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 = G::from_u64(0); let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_24, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __v_34: G = __r_arr[9]; let __v_35: G = __r_arr[10]; let __v_36: G = __r_arr[11]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_24, __v_37]; 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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(1); if (__v_63 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr range: the range ends before it starts".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = (__v_66 - __v_65); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_64]; let __info = io_buffer.get_info(__v_24, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_68: G = __io_pair.0; let __v_69: G = __io_pair.1; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, (&__args[..]))?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { (*(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31])) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("aggr range: proof count differs from the range".to_string()) }); } let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_56, __v_65]; 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_72: G = __r_arr[0]; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_72, __v_71, __v_65, __v_67, __v_62, __v_58, __v_59, __v_60, __v_61, __v_24, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; let __v_76: G = (__v_68 + __v_69); if (__v_75 != __v_76) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the proofs".to_string()) }); } let __v_77: G = (__v_73 - __v_54); let __v_78: G = G::from_bool((__v_77 == G::ZERO)); let __v_79: G = (__v_74 - __v_55); let __v_80: G = G::from_bool((__v_79 == G::ZERO)); let __v_81: G = (__v_78 * __v_80); if (__v_81 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr range: residual sum differs from the statement".to_string()) }); } let __ret: [G; OUT_290] = []; record.function_queries[290].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 = G::from_u64(0); let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_24, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __v_34: G = __r_arr[9]; let __v_35: G = __r_arr[10]; let __v_36: G = __r_arr[11]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_24, __v_37]; 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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(1); if (__v_63 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr range: the range ends before it starts".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __v_66 - __v_65; let __io_pair: (G, G) = { let __key: [G; 1] = [__v_64]; let __info = io_buffer.get_info(__v_24, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_68: G = __io_pair.0; let __v_69: G = __io_pair.1; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("aggr range: proof count differs from the range".to_string()) }); } let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_56, __v_65]; 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_72: G = __r_arr[0]; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_72, __v_71, __v_65, __v_67, __v_62, __v_58, __v_59, __v_60, __v_61, __v_24, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; let __v_76: G = __v_68 + __v_69; if (__v_75 != __v_76) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the proofs".to_string()) }); } let __v_77: G = __v_73 - __v_54; let __v_78: G = G::from_bool(__v_77 == G::ZERO); let __v_79: G = __v_74 - __v_55; let __v_80: G = G::from_bool(__v_79 == G::ZERO); let __v_81: G = __v_78 * __v_80; if (__v_81 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr range: residual sum differs from the statement".to_string()) }); } let __ret: [G; OUT_290] = []; record.function_queries[290].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_291: usize = 34; const IN_291: usize = 34; const OUT_291: usize = 0; -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 __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __v_44: G = __r_arr[9]; let __v_45: G = __r_arr[10]; let __v_46: G = __r_arr[11]; let __v_47: G = __r_arr[12]; let __v_48: G = __r_arr[13]; let __v_49: G = __r_arr[14]; let __v_50: G = __r_arr[15]; let __v_51: G = __r_arr[16]; let __v_52: G = __r_arr[17]; let __v_53: G = __r_arr[18]; let __v_54: G = G::from_u64(1); let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_54, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __v_58: G = __r_arr[3]; let __v_59: G = __r_arr[4]; let __v_60: G = __r_arr[5]; let __v_61: G = __r_arr[6]; let __v_62: G = __r_arr[7]; let __v_63: G = __r_arr[8]; let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = __r_arr[12]; let __v_68: G = __r_arr[13]; let __v_69: G = __r_arr[14]; let __v_70: G = __r_arr[15]; let __v_71: G = __r_arr[16]; let __v_72: G = __r_arr[17]; let __v_73: G = __r_arr[18]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = __r_arr[5]; let __v_80: G = __r_arr[6]; let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; let __v_84: G = __r_arr[10]; let __v_85: G = __r_arr[11]; let __v_86: G = __r_arr[12]; let __v_87: G = __r_arr[13]; let __v_88: G = __r_arr[14]; let __v_89: G = __r_arr[15]; let __v_90: G = __r_arr[16]; let __v_91: G = __r_arr[17]; let __v_92: G = __r_arr[18]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_35, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; if (__v_93 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: children verify different batches".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; if (__v_94 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: output names a different batch than the children".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_95: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_95 != __v_96) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_96.as_canonical_u64(), msg: Some("aggr range: children are not adjacent".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; if (__v_97 != __v_98) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_98.as_canonical_u64(), msg: Some("aggr range: output starts elsewhere than the left child".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; if (__v_99 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: Some("aggr range: output ends elsewhere than the right child".to_string()) }); } let __v_101: G = (__v_52 + __v_72); let __v_102: G = (__v_53 + __v_73); let __v_103: G = (__v_101 - __v_91); let __v_104: G = G::from_bool((__v_103 == G::ZERO)); let __v_105: G = (__v_102 - __v_92); let __v_106: G = G::from_bool((__v_105 == G::ZERO)); let __v_107: G = (__v_104 * __v_106); if (__v_107 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: output residual is not the children's sum".to_string()) }); } let __ret: [G; OUT_291] = []; record.function_queries[291].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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 __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __v_44: G = __r_arr[9]; let __v_45: G = __r_arr[10]; let __v_46: G = __r_arr[11]; let __v_47: G = __r_arr[12]; let __v_48: G = __r_arr[13]; let __v_49: G = __r_arr[14]; let __v_50: G = __r_arr[15]; let __v_51: G = __r_arr[16]; let __v_52: G = __r_arr[17]; let __v_53: G = __r_arr[18]; let __v_54: G = G::from_u64(1); let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_54, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __v_58: G = __r_arr[3]; let __v_59: G = __r_arr[4]; let __v_60: G = __r_arr[5]; let __v_61: G = __r_arr[6]; let __v_62: G = __r_arr[7]; let __v_63: G = __r_arr[8]; let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = __r_arr[12]; let __v_68: G = __r_arr[13]; let __v_69: G = __r_arr[14]; let __v_70: G = __r_arr[15]; let __v_71: G = __r_arr[16]; let __v_72: G = __r_arr[17]; let __v_73: G = __r_arr[18]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = __r_arr[5]; let __v_80: G = __r_arr[6]; let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; let __v_84: G = __r_arr[10]; let __v_85: G = __r_arr[11]; let __v_86: G = __r_arr[12]; let __v_87: G = __r_arr[13]; let __v_88: G = __r_arr[14]; let __v_89: G = __r_arr[15]; let __v_90: G = __r_arr[16]; let __v_91: G = __r_arr[17]; let __v_92: G = __r_arr[18]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_35, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; if (__v_93 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: children verify different batches".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; if (__v_94 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: output names a different batch than the children".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_95: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_95 != __v_96) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_96.as_canonical_u64(), msg: Some("aggr range: children are not adjacent".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; if (__v_97 != __v_98) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_98.as_canonical_u64(), msg: Some("aggr range: output starts elsewhere than the left child".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; if (__v_99 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: Some("aggr range: output ends elsewhere than the right child".to_string()) }); } let __v_101: G = __v_52 + __v_72; let __v_102: G = __v_53 + __v_73; let __v_103: G = __v_101 - __v_91; let __v_104: G = G::from_bool(__v_103 == G::ZERO); let __v_105: G = __v_102 - __v_92; let __v_106: G = G::from_bool(__v_105 == G::ZERO); let __v_107: G = __v_104 * __v_106; if (__v_107 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: output residual is not the children's sum".to_string()) }); } let __ret: [G; OUT_291] = []; record.function_queries[291].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_292: usize = 34; const IN_292: usize = 34; const OUT_292: usize = 0; -fn aiur_fn_292(inp: [G; IN_292], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __v_44: G = __r_arr[9]; let __v_45: G = __r_arr[10]; let __v_46: G = __r_arr[11]; let __v_47: G = __r_arr[12]; let __v_48: G = __r_arr[13]; let __v_49: G = __r_arr[14]; let __v_50: G = __r_arr[15]; let __v_51: G = __r_arr[16]; let __v_52: G = __r_arr[17]; let __v_53: G = __r_arr[18]; let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; let __v_64: G = __r_arr[10]; let __v_65: G = __r_arr[11]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_66, __v_35]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_67]; 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_69: G = __r_arr[0]; let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_69]; 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_70: G = __r_arr[0]; if (__v_70 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; if (__v_71 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr range: root range does not start at shard 0".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_72 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("aggr range: root range does not end at the last shard".to_string()) }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_68, __v_34, __v_34]; 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_73: G = __r_arr[0]; if (__v_73 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_52, __v_53, __v_68, __v_74, __v_75, __v_76, __v_77]; 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_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = G::from_bool((__v_79 == G::ZERO)); let __v_82: G = G::from_bool((__v_80 == G::ZERO)); let __v_83: G = (__v_81 * __v_82); if (__v_83 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("aggr range: the batch does not balance".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_67]; 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_84: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_84]; 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_85: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_85]; 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_86: G = __r_arr[0]; let __v_87: G = G::from_u64(10); if (__v_86 != __v_87) { return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_87.as_canonical_u64(), msg: Some("aggr range: batch must carry a 10-word verify_claim claim".to_string()) }); } let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_85, __v_34]; 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_88: G = __r_arr[0]; if (__v_88 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr range: batch claim has the wrong channel".to_string()) }); } let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_85, __v_66]; 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_89: G = __r_arr[0]; if (__v_89 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("aggr range: batch claim has the wrong entrypoint".to_string()) }); } let __v_90: G = G::from_u64(2); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_85, __v_90]; 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_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __v_94: G = __r_arr[3]; let __v_95: G = __r_arr[4]; let __v_96: G = __r_arr[5]; let __v_97: G = __r_arr[6]; let __v_98: G = __r_arr[7]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_292] = []; record.function_queries[292].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_292(inp: [G; IN_292], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __v_44: G = __r_arr[9]; let __v_45: G = __r_arr[10]; let __v_46: G = __r_arr[11]; let __v_47: G = __r_arr[12]; let __v_48: G = __r_arr[13]; let __v_49: G = __r_arr[14]; let __v_50: G = __r_arr[15]; let __v_51: G = __r_arr[16]; let __v_52: G = __r_arr[17]; let __v_53: G = __r_arr[18]; let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; let __v_64: G = __r_arr[10]; let __v_65: G = __r_arr[11]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_66, __v_35]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_67]; 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_69: G = __r_arr[0]; let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_69]; 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_70: G = __r_arr[0]; if (__v_70 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; if (__v_71 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr range: root range does not start at shard 0".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_72 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("aggr range: root range does not end at the last shard".to_string()) }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_68, __v_34, __v_34]; 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_73: G = __r_arr[0]; if (__v_73 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_52, __v_53, __v_68, __v_74, __v_75, __v_76, __v_77]; 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_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = G::from_bool(__v_79 == G::ZERO); let __v_82: G = G::from_bool(__v_80 == G::ZERO); let __v_83: G = __v_81 * __v_82; if (__v_83 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("aggr range: the batch does not balance".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_67]; 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_84: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_84]; 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_85: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_85]; 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_86: G = __r_arr[0]; let __v_87: G = G::from_u64(10); if (__v_86 != __v_87) { return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_87.as_canonical_u64(), msg: Some("aggr range: batch must carry a 10-word verify_claim claim".to_string()) }); } let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_85, __v_34]; 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_88: G = __r_arr[0]; if (__v_88 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr range: batch claim has the wrong channel".to_string()) }); } let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_85, __v_66]; 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_89: G = __r_arr[0]; if (__v_89 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("aggr range: batch claim has the wrong entrypoint".to_string()) }); } let __v_90: G = G::from_u64(2); let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_85, __v_90]; 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_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __v_94: G = __r_arr[3]; let __v_95: G = __r_arr[4]; let __v_96: G = __r_arr[5]; let __v_97: G = __r_arr[6]; let __v_98: G = __r_arr[7]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_292] = []; record.function_queries[292].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_293: usize = 16; const IN_293: usize = 16; const OUT_293: usize = 0; -fn aiur_fn_293(inp: [G; IN_293], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(80); if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_16, __v_18, __v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(103); let __v_23: G = G::from_u64(230); let __v_24: G = G::from_u64(9); let __v_25: G = G::from_u64(106); let __v_26: G = G::from_u64(133); let __v_27: G = G::from_u64(174); let __v_28: G = G::from_u64(187); let __v_29: G = G::from_u64(114); let __v_30: G = G::from_u64(243); let __v_31: G = G::from_u64(110); let __v_32: G = G::from_u64(60); let __v_33: G = G::from_u64(58); let __v_34: G = G::from_u64(245); let __v_35: G = G::from_u64(79); let __v_36: G = G::from_u64(165); let __v_37: G = G::from_u64(127); let __v_38: G = G::from_u64(82); let __v_39: G = G::from_u64(14); let __v_40: G = G::from_u64(81); let __v_41: G = G::from_u64(140); let __v_42: G = G::from_u64(104); let __v_43: G = G::from_u64(5); let __v_44: G = G::from_u64(155); let __v_45: G = G::from_u64(171); let __v_46: G = G::from_u64(217); let __v_47: G = G::from_u64(131); let __v_48: G = G::from_u64(31); let __v_49: G = G::from_u64(25); let __v_50: G = G::from_u64(205); let __v_51: G = G::from_u64(224); let __v_52: G = G::from_u64(91); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 3] = [__v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 8] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_22, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 34] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_21, __v_54, __v_17, __v_17, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = __r_arr[3]; let __v_63: G = __r_arr[4]; let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __v_67: G = __r_arr[8]; let __v_68: G = __r_arr[9]; let __v_69: G = __r_arr[10]; let __v_70: G = __r_arr[11]; let __v_71: G = __r_arr[12]; let __v_72: G = __r_arr[13]; let __v_73: G = __r_arr[14]; let __v_74: G = __r_arr[15]; let __v_75: G = __r_arr[16]; let __v_76: G = __r_arr[17]; let __v_77: G = __r_arr[18]; let __v_78: G = __r_arr[19]; let __v_79: G = __r_arr[20]; let __v_80: G = __r_arr[21]; let __v_81: G = __r_arr[22]; let __v_82: G = __r_arr[23]; let __v_83: G = __r_arr[24]; let __v_84: G = __r_arr[25]; let __v_85: G = __r_arr[26]; let __v_86: G = __r_arr[27]; let __v_87: G = __r_arr[28]; let __v_88: G = __r_arr[29]; let __v_89: G = __r_arr[30]; let __v_90: G = __r_arr[31]; let __v_91: G = G::from_u64(256); let __v_92: G = (__v_91 * __v_60); let __v_93: G = G::from_u64(65536); let __v_94: G = (__v_93 * __v_61); let __v_95: G = G::from_u64(16777216); let __v_96: G = (__v_95 * __v_62); let __v_97: G = (__v_94 + __v_96); let __v_98: G = (__v_92 + __v_97); let __v_99: G = (__v_59 + __v_98); let __v_100: G = (__v_91 * __v_64); let __v_101: G = (__v_93 * __v_65); let __v_102: G = (__v_95 * __v_66); let __v_103: G = (__v_101 + __v_102); let __v_104: G = (__v_100 + __v_103); let __v_105: G = (__v_63 + __v_104); let __v_106: G = (__v_91 * __v_68); let __v_107: G = (__v_93 * __v_69); let __v_108: G = (__v_95 * __v_70); let __v_109: G = (__v_107 + __v_108); let __v_110: G = (__v_106 + __v_109); let __v_111: G = (__v_67 + __v_110); let __v_112: G = (__v_91 * __v_72); let __v_113: G = (__v_93 * __v_73); let __v_114: G = (__v_95 * __v_74); let __v_115: G = (__v_113 + __v_114); let __v_116: G = (__v_112 + __v_115); let __v_117: G = (__v_71 + __v_116); let __v_118: G = (__v_91 * __v_76); let __v_119: G = (__v_93 * __v_77); let __v_120: G = (__v_95 * __v_78); let __v_121: G = (__v_119 + __v_120); let __v_122: G = (__v_118 + __v_121); let __v_123: G = (__v_75 + __v_122); let __v_124: G = (__v_91 * __v_80); let __v_125: G = (__v_93 * __v_81); let __v_126: G = (__v_95 * __v_82); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_124 + __v_127); let __v_129: G = (__v_79 + __v_128); let __v_130: G = (__v_91 * __v_84); let __v_131: G = (__v_93 * __v_85); let __v_132: G = (__v_95 * __v_86); let __v_133: G = (__v_131 + __v_132); let __v_134: G = (__v_130 + __v_133); let __v_135: G = (__v_83 + __v_134); let __v_136: G = (__v_91 * __v_88); let __v_137: G = (__v_93 * __v_89); let __v_138: G = (__v_95 * __v_90); let __v_139: G = (__v_137 + __v_138); let __v_140: G = (__v_136 + __v_139); let __v_141: G = (__v_87 + __v_140); if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; 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_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_143]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_145]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_146: G = __r_arr[0]; let __v_147: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_147]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_149]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_150: G = __r_arr[0]; let __v_151: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_151]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_153]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_155]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_157]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_159]; 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_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_163]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_164: G = __r_arr[0]; let __v_165: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_166: G = __r_arr[0]; let __v_167: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_167]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __v_169: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_169]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_170: G = __r_arr[0]; let __v_171: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_171]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_175]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_176: G = __r_arr[0]; let __v_177: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; if (__v_178 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } if (__v_179 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } if (__v_180 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_142]; 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_181: G = __r_arr[0]; let __v_182: G = __r_arr[1]; let __v_183: G = __r_arr[2]; let __v_184: G = __r_arr[3]; let __v_185: G = __r_arr[4]; let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; let __v_192: G = __r_arr[3]; let __v_193: G = __r_arr[4]; let __v_194: G = __r_arr[5]; let __v_195: G = __r_arr[6]; let __v_196: G = __r_arr[7]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_144, __v_146, __v_148, __v_150, __v_152, __v_154, __v_156, __v_158]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_197: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_162, __v_164, __v_166, __v_168, __v_170, __v_172, __v_174, __v_176]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, (&__args[..]))?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { (*(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14])) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_198: G = __r_arr[0]; let __v_199: G = G::from_u64(6); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_199, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_200: G = __io_pair.0; let __v_201: G = __io_pair.1; if (__v_201 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: shape hint must be exactly one byte".to_string()) }); } let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_199, __v_200, __v_201]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { (*(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3])) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_202]; 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_203: G = __r_arr[0]; let __v_204: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_204.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_205: G = __loaded[0]; let __v_206: G = __loaded[1]; let __v_207: G = __loaded[2]; if (__v_205 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_205.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } if (__v_206 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } if (__v_207 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } match __v_203.as_canonical_u64() { 0u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_208: G = G::from_u64(0); let __v_209: G = G::from_u64(1); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(0); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_208: G = G::from_u64(0); let __v_209: G = G::from_u64(1); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(0); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, (&__args[..]))?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { (*(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292])) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_203.as_canonical_u64())); }, } }) } +fn aiur_fn_293(inp: [G; IN_293], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(80); if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_16, __v_18, __v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(103); let __v_23: G = G::from_u64(230); let __v_24: G = G::from_u64(9); let __v_25: G = G::from_u64(106); let __v_26: G = G::from_u64(133); let __v_27: G = G::from_u64(174); let __v_28: G = G::from_u64(187); let __v_29: G = G::from_u64(114); let __v_30: G = G::from_u64(243); let __v_31: G = G::from_u64(110); let __v_32: G = G::from_u64(60); let __v_33: G = G::from_u64(58); let __v_34: G = G::from_u64(245); let __v_35: G = G::from_u64(79); let __v_36: G = G::from_u64(165); let __v_37: G = G::from_u64(127); let __v_38: G = G::from_u64(82); let __v_39: G = G::from_u64(14); let __v_40: G = G::from_u64(81); let __v_41: G = G::from_u64(140); let __v_42: G = G::from_u64(104); let __v_43: G = G::from_u64(5); let __v_44: G = G::from_u64(155); let __v_45: G = G::from_u64(171); let __v_46: G = G::from_u64(217); let __v_47: G = G::from_u64(131); let __v_48: G = G::from_u64(31); let __v_49: G = G::from_u64(25); let __v_50: G = G::from_u64(205); let __v_51: G = G::from_u64(224); let __v_52: G = G::from_u64(91); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 3] = [__v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 8] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_22, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 34] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_21, __v_54, __v_17, __v_17, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = __r_arr[3]; let __v_63: G = __r_arr[4]; let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __v_67: G = __r_arr[8]; let __v_68: G = __r_arr[9]; let __v_69: G = __r_arr[10]; let __v_70: G = __r_arr[11]; let __v_71: G = __r_arr[12]; let __v_72: G = __r_arr[13]; let __v_73: G = __r_arr[14]; let __v_74: G = __r_arr[15]; let __v_75: G = __r_arr[16]; let __v_76: G = __r_arr[17]; let __v_77: G = __r_arr[18]; let __v_78: G = __r_arr[19]; let __v_79: G = __r_arr[20]; let __v_80: G = __r_arr[21]; let __v_81: G = __r_arr[22]; let __v_82: G = __r_arr[23]; let __v_83: G = __r_arr[24]; let __v_84: G = __r_arr[25]; let __v_85: G = __r_arr[26]; let __v_86: G = __r_arr[27]; let __v_87: G = __r_arr[28]; let __v_88: G = __r_arr[29]; let __v_89: G = __r_arr[30]; let __v_90: G = __r_arr[31]; let __v_91: G = G::from_u64(256); let __v_92: G = __v_91 * __v_60; let __v_93: G = G::from_u64(65536); let __v_94: G = __v_93 * __v_61; let __v_95: G = G::from_u64(16777216); let __v_96: G = __v_95 * __v_62; let __v_97: G = __v_94 + __v_96; let __v_98: G = __v_92 + __v_97; let __v_99: G = __v_59 + __v_98; let __v_100: G = __v_91 * __v_64; let __v_101: G = __v_93 * __v_65; let __v_102: G = __v_95 * __v_66; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_100 + __v_103; let __v_105: G = __v_63 + __v_104; let __v_106: G = __v_91 * __v_68; let __v_107: G = __v_93 * __v_69; let __v_108: G = __v_95 * __v_70; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_106 + __v_109; let __v_111: G = __v_67 + __v_110; let __v_112: G = __v_91 * __v_72; let __v_113: G = __v_93 * __v_73; let __v_114: G = __v_95 * __v_74; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_112 + __v_115; let __v_117: G = __v_71 + __v_116; let __v_118: G = __v_91 * __v_76; let __v_119: G = __v_93 * __v_77; let __v_120: G = __v_95 * __v_78; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_118 + __v_121; let __v_123: G = __v_75 + __v_122; let __v_124: G = __v_91 * __v_80; let __v_125: G = __v_93 * __v_81; let __v_126: G = __v_95 * __v_82; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_124 + __v_127; let __v_129: G = __v_79 + __v_128; let __v_130: G = __v_91 * __v_84; let __v_131: G = __v_93 * __v_85; let __v_132: G = __v_95 * __v_86; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_130 + __v_133; let __v_135: G = __v_83 + __v_134; let __v_136: G = __v_91 * __v_88; let __v_137: G = __v_93 * __v_89; let __v_138: G = __v_95 * __v_90; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_136 + __v_139; let __v_141: G = __v_87 + __v_140; if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; 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_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_143]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_145]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_146: G = __r_arr[0]; let __v_147: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_147]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_149]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_150: G = __r_arr[0]; let __v_151: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_151]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_153]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_155]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_157]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_159]; 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_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_163]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_164: G = __r_arr[0]; let __v_165: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_166: G = __r_arr[0]; let __v_167: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_167]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __v_169: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_169]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_170: G = __r_arr[0]; let __v_171: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_171]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_175]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_176: G = __r_arr[0]; let __v_177: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; if (__v_178 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } if (__v_179 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } if (__v_180 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_142]; 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_181: G = __r_arr[0]; let __v_182: G = __r_arr[1]; let __v_183: G = __r_arr[2]; let __v_184: G = __r_arr[3]; let __v_185: G = __r_arr[4]; let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; let __v_192: G = __r_arr[3]; let __v_193: G = __r_arr[4]; let __v_194: G = __r_arr[5]; let __v_195: G = __r_arr[6]; let __v_196: G = __r_arr[7]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_144, __v_146, __v_148, __v_150, __v_152, __v_154, __v_156, __v_158]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_197: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_162, __v_164, __v_166, __v_168, __v_170, __v_172, __v_174, __v_176]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_198: G = __r_arr[0]; let __v_199: G = G::from_u64(6); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_199, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_200: G = __io_pair.0; let __v_201: G = __io_pair.1; if (__v_201 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: shape hint must be exactly one byte".to_string()) }); } let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_199, __v_200, __v_201]; let __cu = true; { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_202]; 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_203: G = __r_arr[0]; let __v_204: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_204.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_205: G = __loaded[0]; let __v_206: G = __loaded[1]; let __v_207: G = __loaded[2]; if (__v_205 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_205.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } if (__v_206 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } if (__v_207 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } match __v_203.as_canonical_u64() { 0u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_208: G = G::from_u64(0); let __v_209: G = G::from_u64(1); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(0); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_208: G = G::from_u64(0); let __v_209: G = G::from_u64(1); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(0); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_209, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_208, __v_208, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(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 __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_293] = []; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_203.as_canonical_u64())); }, } }) } const INPUT_SIZE_294: usize = 2; const IN_294: usize = 2; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __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_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_294] = [__v_4]; record.function_queries[294].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __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_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_294] = [__v_4]; record.function_queries[294].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_295: usize = 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 __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; match __v_1.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_295] = [__v_27]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_26]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_27 + __v_28); let __ret: [G; OUT_295] = [__v_29]; record.function_queries[295].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; match __v_1.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_295] = [__v_27]; record.function_queries[295].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_26]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = __v_27 + __v_28; let __ret: [G; OUT_295] = [__v_29]; 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 = 1; const IN_296: usize = 1; 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_296] = [__v_4]; record.function_queries[296].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_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_296] = [__v_6]; record.function_queries[296].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_296] = [__v_4]; record.function_queries[296].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_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_296] = [__v_6]; record.function_queries[296].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_297: usize = 1; const IN_297: usize = 1; 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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_297] = [__v_5]; record.function_queries[297].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_5 + __v_6); let __ret: [G; OUT_297] = [__v_7]; record.function_queries[297].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_297] = [__v_5]; record.function_queries[297].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = __v_5 + __v_6; let __ret: [G; OUT_297] = [__v_7]; record.function_queries[297].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_298: usize = 2; const IN_298: usize = 2; const OUT_298: usize = 1; -fn aiur_fn_298(inp: [G; IN_298], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_298] = [__v_1]; record.function_queries[298].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __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_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_298] = [__v_7]; record.function_queries[298].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_298] = [__v_1]; record.function_queries[298].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __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_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_298] = [__v_7]; record.function_queries[298].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_299: usize = 1; const IN_299: usize = 1; const OUT_299: usize = 1; -fn aiur_fn_299(inp: [G; IN_299], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_299] = [__v_7]; record.function_queries[299].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6]; 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_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_299] = [__v_9]; record.function_queries[299].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.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 __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_299] = [__v_7]; record.function_queries[299].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6]; 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_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_299] = [__v_9]; record.function_queries[299].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_300: usize = 1; const IN_300: usize = 1; 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 __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_8]; record.function_queries[300].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 + __v_9); let __ret: [G; OUT_300] = [__v_10]; record.function_queries[300].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_8]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = __v_8 + __v_9; let __ret: [G; OUT_300] = [__v_10]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_301: usize = 1; const IN_301: usize = 1; 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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_301] = [__v_11]; record.function_queries[301].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__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_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_301] = [__v_13]; record.function_queries[301].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_301] = [__v_11]; record.function_queries[301].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__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_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_301] = [__v_13]; record.function_queries[301].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_302: usize = 1; const IN_302: usize = 1; 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 __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; match __v_1.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_302] = [__v_12]; record.function_queries[302].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_12 + __v_13); let __ret: [G; OUT_302] = [__v_14]; record.function_queries[302].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; match __v_1.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_302] = [__v_12]; record.function_queries[302].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = __v_12 + __v_13; let __ret: [G; OUT_302] = [__v_14]; record.function_queries[302].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_303: usize = 2; const IN_303: usize = 2; const OUT_303: usize = 4; -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 __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]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_303] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[303].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 __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]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_303] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_304: usize = 1; const IN_304: usize = 1; 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_304] = [__v_4]; record.function_queries[304].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_304] = [__v_4]; record.function_queries[304].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_304] = [__v_4]; record.function_queries[304].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_304] = [__v_4]; record.function_queries[304].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_305: usize = 2; const IN_305: usize = 2; const OUT_305: usize = 2; -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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __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_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_305] = [__v_4, __v_5]; record.function_queries[305].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __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_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_305] = [__v_4, __v_5]; record.function_queries[305].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } 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; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_306] = [__v_1]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_11, __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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_306] = [__v_14]; record.function_queries[306].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +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; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_306] = [__v_1]; record.function_queries[306].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_11, __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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_306] = [__v_14]; 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 = 1; const IN_307: usize = 1; 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 __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_307] = [__v_6]; 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_5]; 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_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_307] = [__v_8]; record.function_queries[307].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +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 __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_307] = [__v_6]; 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_5]; 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_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_307] = [__v_8]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_308: usize = 2; const IN_308: usize = 2; 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_308] = [__v_0]; record.function_queries[308].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_308] = { let __args: [G; IN_308] = [__v_0, __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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_308] = [__v_7]; record.function_queries[308].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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 __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_308] = [__v_0]; record.function_queries[308].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_308] = { let __args: [G; IN_308] = [__v_0, __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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_308] = [__v_7]; record.function_queries[308].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_309] = [__v_0]; record.function_queries[309].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_309] = { let __args: [G; IN_309] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_309] = [__v_10]; record.function_queries[309].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_309] = [__v_0]; record.function_queries[309].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_309] = { let __args: [G; IN_309] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_309] = [__v_10]; record.function_queries[309].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_310: usize = 2; const IN_310: usize = 2; const OUT_310: usize = 8; -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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, (&__args[..]))?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { (*(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312])) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[310].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[310].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_311] = [__v_0]; record.function_queries[311].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_311] = { let __args: [G; IN_311] = [__v_0, __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_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_311] = [__v_8]; record.function_queries[311].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_311] = [__v_0]; record.function_queries[311].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_311] = { let __args: [G; IN_311] = [__v_0, __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_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_311] = [__v_8]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_312] = [__v_0]; record.function_queries[312].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_312] = { let __args: [G; IN_312] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, (&__args[..]))?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { (*(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312])) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_312] = [__v_14]; record.function_queries[312].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_312] = [__v_0]; record.function_queries[312].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_312] = { let __args: [G; IN_312] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_312] = [__v_14]; record.function_queries[312].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } pub(crate) fn execute_generated(fun_idx: usize, args: &[G], record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result, ExecError> { if (record.memory_queries.get_index(0).map(|(size, _)| (*size)) != Some(3)) { return Err(ExecError::InvalidMemorySize(3)); } if (record.memory_queries.get_index(1).map(|(size, _)| (*size)) != Some(4)) { return Err(ExecError::InvalidMemorySize(4)); } if (record.memory_queries.get_index(2).map(|(size, _)| (*size)) != Some(5)) { return Err(ExecError::InvalidMemorySize(5)); } if (record.memory_queries.get_index(3).map(|(size, _)| (*size)) != Some(6)) { return Err(ExecError::InvalidMemorySize(6)); } if (record.memory_queries.get_index(4).map(|(size, _)| (*size)) != Some(7)) { return Err(ExecError::InvalidMemorySize(7)); } if (record.memory_queries.get_index(5).map(|(size, _)| (*size)) != Some(8)) { return Err(ExecError::InvalidMemorySize(8)); } if (record.memory_queries.get_index(6).map(|(size, _)| (*size)) != Some(10)) { return Err(ExecError::InvalidMemorySize(10)); } if (record.memory_queries.get_index(7).map(|(size, _)| (*size)) != Some(11)) { return Err(ExecError::InvalidMemorySize(11)); } if (record.memory_queries.get_index(8).map(|(size, _)| (*size)) != Some(26)) { return Err(ExecError::InvalidMemorySize(26)); } if (record.memory_queries.get_index(9).map(|(size, _)| (*size)) != Some(32)) { return Err(ExecError::InvalidMemorySize(32)); } if (record.memory_queries.get_index(10).map(|(size, _)| (*size)) != Some(34)) { return Err(ExecError::InvalidMemorySize(34)); } let __input_hash = aiur::querymap::hash_g_slice(args); match (fun_idx as u64) { 0u64 => { let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_0::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 1u64 => { let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_1::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 2u64 => { let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_2::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 3u64 => { let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_3::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 4u64 => { let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_4::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 5u64 => { let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_5::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 6u64 => { let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_6::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 7u64 => { let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_7::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 8u64 => { let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_8::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 9u64 => { let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_9::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 10u64 => { let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_10::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 11u64 => { let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_11::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 12u64 => { let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_12::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 13u64 => { let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_13::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 14u64 => { let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_14::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 15u64 => { let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_15::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 16u64 => { let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_16::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 17u64 => { let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_17::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 18u64 => { let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_18::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 19u64 => { let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_19::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 20u64 => { let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_20::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 21u64 => { let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_21::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 22u64 => { let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_22::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 23u64 => { let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_23::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 24u64 => { let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_24::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 25u64 => { let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_25::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 26u64 => { let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_26::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 27u64 => { let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_27::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 28u64 => { let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_28::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 29u64 => { let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_29::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 30u64 => { let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_30::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 31u64 => { let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_31::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 32u64 => { let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_32::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 33u64 => { let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_33::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 34u64 => { let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_34::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 35u64 => { let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_35::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 36u64 => { let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_36::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 37u64 => { let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_37::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 38u64 => { let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_38::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 39u64 => { let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_39::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 40u64 => { let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_40::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 41u64 => { let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_41::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 42u64 => { let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_42::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 43u64 => { let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_43::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 44u64 => { let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_44::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 45u64 => { let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_45::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 46u64 => { let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_46::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 47u64 => { let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_47::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 48u64 => { let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_48::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 49u64 => { let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_49::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 50u64 => { let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_50::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 51u64 => { let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_51::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 52u64 => { let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_52::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 53u64 => { let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_53::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 54u64 => { let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_54::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 55u64 => { let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_55::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 56u64 => { let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_56::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 57u64 => { let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_57::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 58u64 => { let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_58::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 59u64 => { let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_59::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 60u64 => { let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_60::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 61u64 => { let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_61::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 62u64 => { let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_62::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 63u64 => { let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_63::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 64u64 => { let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_64::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 65u64 => { let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_65::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 66u64 => { let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_66::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 67u64 => { let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_67::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 68u64 => { let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_68::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 69u64 => { let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_69::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 70u64 => { let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_70::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 71u64 => { let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_71::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 72u64 => { let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_72::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 73u64 => { let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_73::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 74u64 => { let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_74::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 75u64 => { let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_75::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 76u64 => { let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_76::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 77u64 => { let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_77::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 78u64 => { let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_78::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 79u64 => { let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_79::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 80u64 => { let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_80::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 81u64 => { let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_81::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 82u64 => { let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_82::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 83u64 => { let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_83::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 84u64 => { let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_84::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 85u64 => { let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_85::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 86u64 => { let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_86::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 87u64 => { let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_87::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 88u64 => { let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_88::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 89u64 => { let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_89::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 90u64 => { let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_90::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 91u64 => { let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_91::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 92u64 => { let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_92::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 93u64 => { let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_93::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 94u64 => { let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_94::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 95u64 => { let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_95::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 96u64 => { let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_96::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 97u64 => { let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_97::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 98u64 => { let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_98::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 99u64 => { let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_99::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 100u64 => { let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_100::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 101u64 => { let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_101::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 102u64 => { let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_102::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 103u64 => { let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_103::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 104u64 => { let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_104::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 105u64 => { let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_105::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 106u64 => { let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_106::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 107u64 => { let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_107::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 108u64 => { let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_108::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 109u64 => { let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_109::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 110u64 => { let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_110::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 111u64 => { let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_111::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 112u64 => { let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_112::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 113u64 => { let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_113::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 114u64 => { let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_114::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 115u64 => { let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_115::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 116u64 => { let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_116::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 117u64 => { let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_117::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 118u64 => { let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_118::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 119u64 => { let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_119::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 120u64 => { let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_120::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 121u64 => { let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_121::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 122u64 => { let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_122::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 123u64 => { let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_123::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 124u64 => { let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_124::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 125u64 => { let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_125::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 126u64 => { let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_126::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 127u64 => { let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_127::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 128u64 => { let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_128::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 129u64 => { let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_129::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 130u64 => { let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_130::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 131u64 => { let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_131::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 132u64 => { let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_132::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 133u64 => { let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_133::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 134u64 => { let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_134::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 135u64 => { let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_135::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 136u64 => { let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_136::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 137u64 => { let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_137::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 138u64 => { let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_138::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 139u64 => { let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_139::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 140u64 => { let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_140::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 141u64 => { let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_141::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 142u64 => { let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_142::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 143u64 => { let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_143::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 144u64 => { let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_144::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 145u64 => { let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_145::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 146u64 => { let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_146::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 147u64 => { let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_147::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 148u64 => { let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_148::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 149u64 => { let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_149::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 150u64 => { let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_150::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 151u64 => { let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_151::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 152u64 => { let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_152::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 153u64 => { let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_153::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 154u64 => { let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_154::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 155u64 => { let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_155::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 156u64 => { let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_156::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 157u64 => { let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_157::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 158u64 => { let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_158::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 159u64 => { let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_159::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 160u64 => { let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_160::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 161u64 => { let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_161::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 162u64 => { let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_162::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 163u64 => { let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_163::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 164u64 => { let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_164::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 165u64 => { let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_165::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 166u64 => { let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_166::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 167u64 => { let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_167::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 168u64 => { let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_168::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 169u64 => { let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_169::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 170u64 => { let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_170::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 171u64 => { let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_171::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 172u64 => { let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_172::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 173u64 => { let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_173::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 174u64 => { let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_174::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 175u64 => { let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_175::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 176u64 => { let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_176::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 177u64 => { let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_177::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 178u64 => { let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_178::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 179u64 => { let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_179::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 180u64 => { let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_180::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 181u64 => { let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_181::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 182u64 => { let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_182::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 183u64 => { let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_183::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 184u64 => { let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_184::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 185u64 => { let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_185::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 186u64 => { let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_186::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 187u64 => { let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_187::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 188u64 => { let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_188::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 189u64 => { let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_189::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 190u64 => { let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_190::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 191u64 => { let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_191::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 192u64 => { let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_192::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 193u64 => { let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_193::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 194u64 => { let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_194::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 195u64 => { let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_195::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 196u64 => { let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_196::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 197u64 => { let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_197::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 198u64 => { let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_198::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 199u64 => { let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_199::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 200u64 => { let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_200::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 201u64 => { let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_201::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 202u64 => { let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_202::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 203u64 => { let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_203::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 204u64 => { let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_204::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 205u64 => { let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_205::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 206u64 => { let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_206::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 207u64 => { let __inp: [G; IN_207] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_207::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 208u64 => { let __inp: [G; IN_208] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_208::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 209u64 => { let __inp: [G; IN_209] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_209::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 210u64 => { let __inp: [G; IN_210] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_210::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 211u64 => { let __inp: [G; IN_211] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_211::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 212u64 => { let __inp: [G; IN_212] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_212::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 213u64 => { let __inp: [G; IN_213] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_213::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 214u64 => { let __inp: [G; IN_214] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_214::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 215u64 => { let __inp: [G; IN_215] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_215::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 216u64 => { let __inp: [G; IN_216] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_216::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 217u64 => { let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_217::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 218u64 => { let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_218::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 219u64 => { let __inp: [G; IN_219] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_219::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 220u64 => { let __inp: [G; IN_220] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_220::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 221u64 => { let __inp: [G; IN_221] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_221::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 222u64 => { let __inp: [G; IN_222] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_222::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 223u64 => { let __inp: [G; IN_223] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_223::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 224u64 => { let __inp: [G; IN_224] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_224::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 225u64 => { let __inp: [G; IN_225] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_225::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 226u64 => { let __inp: [G; IN_226] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_226::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 227u64 => { let __inp: [G; IN_227] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_227::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 228u64 => { let __inp: [G; IN_228] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_228::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 229u64 => { let __inp: [G; IN_229] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_229::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 230u64 => { let __inp: [G; IN_230] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_230::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 231u64 => { let __inp: [G; IN_231] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_231::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 232u64 => { let __inp: [G; IN_232] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_232::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 233u64 => { let __inp: [G; IN_233] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_233::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 234u64 => { let __inp: [G; IN_234] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_234::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 235u64 => { let __inp: [G; IN_235] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_235::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 236u64 => { let __inp: [G; IN_236] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_236::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 237u64 => { let __inp: [G; IN_237] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_237::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 238u64 => { let __inp: [G; IN_238] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_238::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 239u64 => { let __inp: [G; IN_239] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_239::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 240u64 => { let __inp: [G; IN_240] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_240::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 241u64 => { let __inp: [G; IN_241] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_241::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 242u64 => { let __inp: [G; IN_242] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_242::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 243u64 => { let __inp: [G; IN_243] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_243::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 244u64 => { let __inp: [G; IN_244] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_244::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 245u64 => { let __inp: [G; IN_245] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_245::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 246u64 => { let __inp: [G; IN_246] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_246::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 247u64 => { let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_247::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 248u64 => { let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_248::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 249u64 => { let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_249::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 250u64 => { let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_250::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 251u64 => { let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_251::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 252u64 => { let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_252::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 253u64 => { let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_253::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 254u64 => { let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_254::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 255u64 => { let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_255::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_256::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_257::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_258::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 259u64 => { let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_259::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 260u64 => { let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_260::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 261u64 => { let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_261::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 262u64 => { let __inp: [G; IN_262] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_262::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 263u64 => { let __inp: [G; IN_263] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_263::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 264u64 => { let __inp: [G; IN_264] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_264::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 265u64 => { let __inp: [G; IN_265] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_265::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 266u64 => { let __inp: [G; IN_266] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_266::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 267u64 => { let __inp: [G; IN_267] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_267::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 268u64 => { let __inp: [G; IN_268] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_268::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 269u64 => { let __inp: [G; IN_269] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_269::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 270u64 => { let __inp: [G; IN_270] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_270::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 271u64 => { let __inp: [G; IN_271] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_271::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 272u64 => { let __inp: [G; IN_272] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_272::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 273u64 => { let __inp: [G; IN_273] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_273::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 274u64 => { let __inp: [G; IN_274] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_274::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 275u64 => { let __inp: [G; IN_275] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_275::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 276u64 => { let __inp: [G; IN_276] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_276::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 277u64 => { let __inp: [G; IN_277] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_277::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 278u64 => { let __inp: [G; IN_278] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_278::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 279u64 => { let __inp: [G; IN_279] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_279::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 280u64 => { let __inp: [G; IN_280] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_280::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 281u64 => { let __inp: [G; IN_281] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_281::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 282u64 => { let __inp: [G; IN_282] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_282::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 283u64 => { let __inp: [G; IN_283] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_283::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 284u64 => { let __inp: [G; IN_284] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_284::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 285u64 => { let __inp: [G; IN_285] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_285::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 286u64 => { let __inp: [G; IN_286] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_286::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 287u64 => { let __inp: [G; IN_287] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_287::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 288u64 => { let __inp: [G; IN_288] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_288::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 289u64 => { let __inp: [G; IN_289] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_289::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 290u64 => { let __inp: [G; IN_290] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_290::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 291u64 => { let __inp: [G; IN_291] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_291::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 292u64 => { let __inp: [G; IN_292] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_292::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 293u64 => { let __inp: [G; IN_293] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_293::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 294u64 => { let __inp: [G; IN_294] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_294::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 295u64 => { let __inp: [G; IN_295] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_295::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 296u64 => { let __inp: [G; IN_296] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_296::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 297u64 => { let __inp: [G; IN_297] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_297::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 298u64 => { let __inp: [G; IN_298] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_298::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 299u64 => { let __inp: [G; IN_299] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_299::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 300u64 => { let __inp: [G; IN_300] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_300::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 301u64 => { let __inp: [G; IN_301] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_301::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 302u64 => { let __inp: [G; IN_302] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_302::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 303u64 => { let __inp: [G; IN_303] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_303::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 304u64 => { let __inp: [G; IN_304] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_304::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 305u64 => { let __inp: [G; IN_305] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_305::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 306u64 => { let __inp: [G; IN_306] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_306::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 307u64 => { let __inp: [G; IN_307] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_307::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 308u64 => { let __inp: [G; IN_308] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_308::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 309u64 => { let __inp: [G; IN_309] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_309::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 310u64 => { let __inp: [G; IN_310] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_310::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 311u64 => { let __inp: [G; IN_311] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_311::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 312u64 => { let __inp: [G; IN_312] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_312::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index ac2b6a378..c4b50a745 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -12,3241 +12,3241 @@ use aiur::execute::{ExecError, IOBuffer, QueryRecord}; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; -fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_1: usize = 2; const IN_1: usize = 2; const OUT_1: usize = 1; -fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = G::from_u64(256); let __v_67: G = (__v_9 * __v_66); let __v_68: G = (__v_67 + __v_8); let __v_69: G = (__v_68 * __v_66); let __v_70: G = (__v_69 + __v_7); let __v_71: G = (__v_70 * __v_66); let __v_72: G = (__v_71 + __v_6); let __v_73: G = (__v_72 * __v_66); let __v_74: G = (__v_73 + __v_5); let __v_75: G = (__v_74 * __v_66); let __v_76: G = (__v_75 + __v_4); let __v_77: G = (__v_76 * __v_66); let __v_78: G = (__v_77 + __v_3); let __v_79: G = (__v_41 * __v_66); let __v_80: G = (__v_79 + __v_40); let __v_81: G = (__v_80 * __v_66); let __v_82: G = (__v_81 + __v_39); let __v_83: G = (__v_82 * __v_66); let __v_84: G = (__v_83 + __v_38); let __v_85: G = (__v_84 * __v_66); let __v_86: G = (__v_85 + __v_37); let __v_87: G = (__v_86 * __v_66); let __v_88: G = (__v_87 + __v_36); let __v_89: G = (__v_88 * __v_66); let __v_90: G = (__v_89 + __v_35); let __v_91: G = (__v_78 - __v_90); match __v_91.as_canonical_u64() { 0u64 => { let __v_92: G = G::from_u64(256); let __v_93: G = (__v_16 * __v_92); let __v_94: G = (__v_93 + __v_15); let __v_95: G = (__v_94 * __v_92); let __v_96: G = (__v_95 + __v_14); let __v_97: G = (__v_96 * __v_92); let __v_98: G = (__v_97 + __v_13); let __v_99: G = (__v_98 * __v_92); let __v_100: G = (__v_99 + __v_12); let __v_101: G = (__v_100 * __v_92); let __v_102: G = (__v_101 + __v_11); let __v_103: G = (__v_102 * __v_92); let __v_104: G = (__v_103 + __v_10); let __v_105: G = (__v_48 * __v_92); let __v_106: G = (__v_105 + __v_47); let __v_107: G = (__v_106 * __v_92); let __v_108: G = (__v_107 + __v_46); let __v_109: G = (__v_108 * __v_92); let __v_110: G = (__v_109 + __v_45); let __v_111: G = (__v_110 * __v_92); let __v_112: G = (__v_111 + __v_44); let __v_113: G = (__v_112 * __v_92); let __v_114: G = (__v_113 + __v_43); let __v_115: G = (__v_114 * __v_92); let __v_116: G = (__v_115 + __v_42); let __v_117: G = (__v_104 - __v_116); match __v_117.as_canonical_u64() { 0u64 => { let __v_118: G = G::from_u64(256); let __v_119: G = (__v_23 * __v_118); let __v_120: G = (__v_119 + __v_22); let __v_121: G = (__v_120 * __v_118); let __v_122: G = (__v_121 + __v_21); let __v_123: G = (__v_122 * __v_118); let __v_124: G = (__v_123 + __v_20); let __v_125: G = (__v_124 * __v_118); let __v_126: G = (__v_125 + __v_19); let __v_127: G = (__v_126 * __v_118); let __v_128: G = (__v_127 + __v_18); let __v_129: G = (__v_128 * __v_118); let __v_130: G = (__v_129 + __v_17); let __v_131: G = (__v_55 * __v_118); let __v_132: G = (__v_131 + __v_54); let __v_133: G = (__v_132 * __v_118); let __v_134: G = (__v_133 + __v_53); let __v_135: G = (__v_134 * __v_118); let __v_136: G = (__v_135 + __v_52); let __v_137: G = (__v_136 * __v_118); let __v_138: G = (__v_137 + __v_51); let __v_139: G = (__v_138 * __v_118); let __v_140: G = (__v_139 + __v_50); let __v_141: G = (__v_140 * __v_118); let __v_142: G = (__v_141 + __v_49); let __v_143: G = (__v_130 - __v_142); match __v_143.as_canonical_u64() { 0u64 => { let __v_144: G = G::from_u64(256); let __v_145: G = (__v_30 * __v_144); let __v_146: G = (__v_145 + __v_29); let __v_147: G = (__v_146 * __v_144); let __v_148: G = (__v_147 + __v_28); let __v_149: G = (__v_148 * __v_144); let __v_150: G = (__v_149 + __v_27); let __v_151: G = (__v_150 * __v_144); let __v_152: G = (__v_151 + __v_26); let __v_153: G = (__v_152 * __v_144); let __v_154: G = (__v_153 + __v_25); let __v_155: G = (__v_154 * __v_144); let __v_156: G = (__v_155 + __v_24); let __v_157: G = (__v_62 * __v_144); let __v_158: G = (__v_157 + __v_61); let __v_159: G = (__v_158 * __v_144); let __v_160: G = (__v_159 + __v_60); let __v_161: G = (__v_160 * __v_144); let __v_162: G = (__v_161 + __v_59); let __v_163: G = (__v_162 * __v_144); let __v_164: G = (__v_163 + __v_58); let __v_165: G = (__v_164 * __v_144); let __v_166: G = (__v_165 + __v_57); let __v_167: G = (__v_166 * __v_144); let __v_168: G = (__v_167 + __v_56); let __v_169: G = (__v_156 - __v_168); match __v_169.as_canonical_u64() { 0u64 => { let __v_170: G = G::from_u64(256); let __v_171: G = (__v_33 * __v_170); let __v_172: G = (__v_171 + __v_32); let __v_173: G = (__v_172 * __v_170); let __v_174: G = (__v_173 + __v_31); let __v_175: G = (__v_65 * __v_170); let __v_176: G = (__v_175 + __v_64); let __v_177: G = (__v_176 * __v_170); let __v_178: G = (__v_177 + __v_63); let __v_179: G = (__v_174 - __v_178); match __v_179.as_canonical_u64() { 0u64 => { let __v_180: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_180: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_170: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_170]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_144: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_144]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_118: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_118]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_92: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_92]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = G::from_u64(256); let __v_67: G = __v_9 * __v_66; let __v_68: G = __v_67 + __v_8; let __v_69: G = __v_68 * __v_66; let __v_70: G = __v_69 + __v_7; let __v_71: G = __v_70 * __v_66; let __v_72: G = __v_71 + __v_6; let __v_73: G = __v_72 * __v_66; let __v_74: G = __v_73 + __v_5; let __v_75: G = __v_74 * __v_66; let __v_76: G = __v_75 + __v_4; let __v_77: G = __v_76 * __v_66; let __v_78: G = __v_77 + __v_3; let __v_79: G = __v_41 * __v_66; let __v_80: G = __v_79 + __v_40; let __v_81: G = __v_80 * __v_66; let __v_82: G = __v_81 + __v_39; let __v_83: G = __v_82 * __v_66; let __v_84: G = __v_83 + __v_38; let __v_85: G = __v_84 * __v_66; let __v_86: G = __v_85 + __v_37; let __v_87: G = __v_86 * __v_66; let __v_88: G = __v_87 + __v_36; let __v_89: G = __v_88 * __v_66; let __v_90: G = __v_89 + __v_35; let __v_91: G = __v_78 - __v_90; match __v_91.as_canonical_u64() { 0u64 => { let __v_92: G = G::from_u64(256); let __v_93: G = __v_16 * __v_92; let __v_94: G = __v_93 + __v_15; let __v_95: G = __v_94 * __v_92; let __v_96: G = __v_95 + __v_14; let __v_97: G = __v_96 * __v_92; let __v_98: G = __v_97 + __v_13; let __v_99: G = __v_98 * __v_92; let __v_100: G = __v_99 + __v_12; let __v_101: G = __v_100 * __v_92; let __v_102: G = __v_101 + __v_11; let __v_103: G = __v_102 * __v_92; let __v_104: G = __v_103 + __v_10; let __v_105: G = __v_48 * __v_92; let __v_106: G = __v_105 + __v_47; let __v_107: G = __v_106 * __v_92; let __v_108: G = __v_107 + __v_46; let __v_109: G = __v_108 * __v_92; let __v_110: G = __v_109 + __v_45; let __v_111: G = __v_110 * __v_92; let __v_112: G = __v_111 + __v_44; let __v_113: G = __v_112 * __v_92; let __v_114: G = __v_113 + __v_43; let __v_115: G = __v_114 * __v_92; let __v_116: G = __v_115 + __v_42; let __v_117: G = __v_104 - __v_116; match __v_117.as_canonical_u64() { 0u64 => { let __v_118: G = G::from_u64(256); let __v_119: G = __v_23 * __v_118; let __v_120: G = __v_119 + __v_22; let __v_121: G = __v_120 * __v_118; let __v_122: G = __v_121 + __v_21; let __v_123: G = __v_122 * __v_118; let __v_124: G = __v_123 + __v_20; let __v_125: G = __v_124 * __v_118; let __v_126: G = __v_125 + __v_19; let __v_127: G = __v_126 * __v_118; let __v_128: G = __v_127 + __v_18; let __v_129: G = __v_128 * __v_118; let __v_130: G = __v_129 + __v_17; let __v_131: G = __v_55 * __v_118; let __v_132: G = __v_131 + __v_54; let __v_133: G = __v_132 * __v_118; let __v_134: G = __v_133 + __v_53; let __v_135: G = __v_134 * __v_118; let __v_136: G = __v_135 + __v_52; let __v_137: G = __v_136 * __v_118; let __v_138: G = __v_137 + __v_51; let __v_139: G = __v_138 * __v_118; let __v_140: G = __v_139 + __v_50; let __v_141: G = __v_140 * __v_118; let __v_142: G = __v_141 + __v_49; let __v_143: G = __v_130 - __v_142; match __v_143.as_canonical_u64() { 0u64 => { let __v_144: G = G::from_u64(256); let __v_145: G = __v_30 * __v_144; let __v_146: G = __v_145 + __v_29; let __v_147: G = __v_146 * __v_144; let __v_148: G = __v_147 + __v_28; let __v_149: G = __v_148 * __v_144; let __v_150: G = __v_149 + __v_27; let __v_151: G = __v_150 * __v_144; let __v_152: G = __v_151 + __v_26; let __v_153: G = __v_152 * __v_144; let __v_154: G = __v_153 + __v_25; let __v_155: G = __v_154 * __v_144; let __v_156: G = __v_155 + __v_24; let __v_157: G = __v_62 * __v_144; let __v_158: G = __v_157 + __v_61; let __v_159: G = __v_158 * __v_144; let __v_160: G = __v_159 + __v_60; let __v_161: G = __v_160 * __v_144; let __v_162: G = __v_161 + __v_59; let __v_163: G = __v_162 * __v_144; let __v_164: G = __v_163 + __v_58; let __v_165: G = __v_164 * __v_144; let __v_166: G = __v_165 + __v_57; let __v_167: G = __v_166 * __v_144; let __v_168: G = __v_167 + __v_56; let __v_169: G = __v_156 - __v_168; match __v_169.as_canonical_u64() { 0u64 => { let __v_170: G = G::from_u64(256); let __v_171: G = __v_33 * __v_170; let __v_172: G = __v_171 + __v_32; let __v_173: G = __v_172 * __v_170; let __v_174: G = __v_173 + __v_31; let __v_175: G = __v_65 * __v_170; let __v_176: G = __v_175 + __v_64; let __v_177: G = __v_176 * __v_170; let __v_178: G = __v_177 + __v_63; let __v_179: G = __v_174 - __v_178; match __v_179.as_canonical_u64() { 0u64 => { let __v_180: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_180: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_170: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_170]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_144: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_144]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_118: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_118]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_92: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_92]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_2: usize = 2; const IN_2: usize = 2; const OUT_2: usize = 1; -fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, (&__args[..]))?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __v_2 - __v_34; match __v_66.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, &__args[..])?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_3: usize = 1; const IN_3: usize = 1; const OUT_3: usize = 1; -fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(4294967295); let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("list depth exceeds u32".to_string()) }); } let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_3] = [__v_4]; record.function_queries[3].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(4294967295); let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("list depth exceeds u32".to_string()) }); } let __v_4: G = __v_0 + __v_3; let __ret: [G; OUT_3] = [__v_4]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_4: usize = 3; const IN_4: usize = 3; const OUT_4: usize = 1; -fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_4] = [__v_4]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, (&__args[..]))?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { (*(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4])) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_4] = [__v_9]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_4] = [__v_4]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_4] = [__v_9]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_5: usize = 3; const IN_5: usize = 3; const OUT_5: usize = 1; -fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; 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); }) } +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_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); }, } }) } +fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_7: usize = 8; const IN_7: usize = 8; const OUT_7: usize = 4; -fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __u32_sum: u128 = (u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_13: G = (__v_12 * __v_12); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __u32_sum: u128 = u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_13: G = __v_12 * __v_12; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[7].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_8: usize = 12; const IN_8: usize = 12; const OUT_8: usize = 4; -fn aiur_fn_8(inp: [G; IN_8], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); let __v_13: G = G::from_u8(__u32_bytes[1]); let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = 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); }) } +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 = 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); }) } +fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[9].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_10: usize = 4; const IN_10: usize = 4; const OUT_10: usize = 4; -fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_10] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_10] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_11: usize = 4; const IN_11: usize = 4; const OUT_11: usize = 4; -fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_11] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_11] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_12: usize = 8; const IN_12: usize = 8; const OUT_12: usize = 4; -fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); let __v_17: G = (__v_10 + __v_13); let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_8 + __v_11; let __v_17: G = __v_10 + __v_13; let __v_18: G = __v_12 + __v_15; let __v_19: G = __v_14 + __v_9; let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_13: usize = 8; const IN_13: usize = 8; const OUT_13: usize = 4; -fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); let __v_17: G = (__v_12 + __v_15); let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_13] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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); }, } }) } +fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = __v_0 - __v_8; let __v_17: G = __v_1 - __v_9; let __v_18: G = __v_2 - __v_10; let __v_19: G = __v_3 - __v_11; let __v_20: G = __v_4 - __v_12; let __v_21: G = __v_5 - __v_13; let __v_22: G = __v_6 - __v_14; let __v_23: G = __v_7 - __v_15; match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_15: usize = 16; const IN_15: usize = 16; const OUT_15: usize = 9; -fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_0), (&__v_8)) } else { aiur::execute::bytes2_add_value(__v_0, __v_8, record) }; let __v_16: G = __b2_out.0; let __v_17: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_1), (&__v_9)) } else { aiur::execute::bytes2_add_value(__v_1, __v_9, record) }; let __v_18: G = __b2_out.0; let __v_19: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_18), (&__v_17)) } else { aiur::execute::bytes2_add_value(__v_18, __v_17, record) }; let __v_20: G = __b2_out.0; let __v_21: G = __b2_out.1; let __v_22: G = (__v_19 + __v_21); let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_2), (&__v_10)) } else { aiur::execute::bytes2_add_value(__v_2, __v_10, record) }; let __v_23: G = __b2_out.0; let __v_24: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_23), (&__v_22)) } else { aiur::execute::bytes2_add_value(__v_23, __v_22, record) }; let __v_25: G = __b2_out.0; let __v_26: G = __b2_out.1; let __v_27: G = (__v_24 + __v_26); let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_3), (&__v_11)) } else { aiur::execute::bytes2_add_value(__v_3, __v_11, record) }; let __v_28: G = __b2_out.0; let __v_29: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_28), (&__v_27)) } else { aiur::execute::bytes2_add_value(__v_28, __v_27, record) }; let __v_30: G = __b2_out.0; let __v_31: G = __b2_out.1; let __v_32: G = (__v_29 + __v_31); let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_4), (&__v_12)) } else { aiur::execute::bytes2_add_value(__v_4, __v_12, record) }; let __v_33: G = __b2_out.0; let __v_34: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_33), (&__v_32)) } else { aiur::execute::bytes2_add_value(__v_33, __v_32, record) }; let __v_35: G = __b2_out.0; let __v_36: G = __b2_out.1; let __v_37: G = (__v_34 + __v_36); let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_5), (&__v_13)) } else { aiur::execute::bytes2_add_value(__v_5, __v_13, record) }; let __v_38: G = __b2_out.0; let __v_39: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_38), (&__v_37)) } else { aiur::execute::bytes2_add_value(__v_38, __v_37, record) }; let __v_40: G = __b2_out.0; let __v_41: G = __b2_out.1; let __v_42: G = (__v_39 + __v_41); let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_6), (&__v_14)) } else { aiur::execute::bytes2_add_value(__v_6, __v_14, record) }; let __v_43: G = __b2_out.0; let __v_44: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_43), (&__v_42)) } else { aiur::execute::bytes2_add_value(__v_43, __v_42, record) }; let __v_45: G = __b2_out.0; let __v_46: G = __b2_out.1; let __v_47: G = (__v_44 + __v_46); let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_7), (&__v_15)) } else { aiur::execute::bytes2_add_value(__v_7, __v_15, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add((&__v_48), (&__v_47)) } else { aiur::execute::bytes2_add_value(__v_48, __v_47, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_15] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +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); }, } }) } +fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_7 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_6 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_5 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 + __v_9; let __ret: [G; OUT_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_0 + __v_8; let __ret: [G; OUT_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_17: usize = 8; const IN_17: usize = 8; const OUT_17: usize = 8; -fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_7 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_6 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); let __ret: [G; OUT_17] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 - __v_8); let __ret: [G; OUT_17] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_7 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_6 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_5 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_0 - __v_8; let __ret: [G; OUT_17] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_18: usize = 8; const IN_18: usize = 8; const OUT_18: usize = 1; -fn aiur_fn_18(inp: [G; IN_18], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_1); let __v_11: G = 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); }) } +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 = 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); }) } +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); }) } +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); }) } +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); }) } +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); }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }, } }) } +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]; let __v_2: G = 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); }, } }) } +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); 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); }, } }) } +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); }) } +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); }) } +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); }) } +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 = 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); }, } }) } +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())); }, } }) } +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]; 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); }, } }) } +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]; 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); }, } }) } +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 __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); }, } }) } +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 = (__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); }, } }) } +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 __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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; 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())); }, } }) } +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]; 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())); }, } }) } +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]; 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); }, } }) } +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]; 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); }, } }) } +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 = 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); }) } +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); }) } +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() { 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); }, } }) } +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() { 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); }, } }) } +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); }, } }) } +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() { 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); }, } }) } +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() { 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); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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); }, } }) } +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]; 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); }) } +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())); }, } }) } +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 = 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); }, } }) } +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); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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())); }, } }) } +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; 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())); }, } }) } +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 __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())); }, } }) } +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]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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]; 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())); }, } }) } +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]; 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); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; 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); }, } }) } +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 __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())); }, } }) } +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]; let __v_11: G = 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); }, } }) } +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 __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); }, } }) } +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]; 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); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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); }, } }) } +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 __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())); }, } }) } +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]; let __v_10: G = inp[10]; let __v_11: G = 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); }, } }) } +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]; 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); }, } }) } +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]; 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); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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())); }, } }) } +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 __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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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())); }, } }) } +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_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); }) } +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_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); }) } +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 __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); }) } +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())); }, } }, } }) } +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())); }, } }) } +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 __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())); }, } }, } }) } +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_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())); }, } }) } +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_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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }) } +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); }) } +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); }) } +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 = 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); }) } +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 __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())); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = 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); }) } +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())); }, } }) } +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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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())); }, } }) } +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]; 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); }) } +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 = 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); }) } +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 = 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); }) } +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]; 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())); }, } }) } +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 = 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); }) } +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 = 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); }) } +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())); }, } }) } +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 = 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); }) } +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 = 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); }) } +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 = 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); }) } +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())); }, } }) } +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 = 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); }) } +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 = 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); }) } +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())); }, } }) } +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 = 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); }) } +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); }) } +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); }) } +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 __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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }) } +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); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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 __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); }) } +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); }) } +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())); }, } }) } +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 __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); }) } +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())); }, } }) } +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 __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())); }, } }) } +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 = 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())); }, } }) } +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); }, } }) } +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 = 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); }) } +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 = 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())); }, } }) } +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); }) } +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); }) } +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]; 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); }) } +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 __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())); }, } }) } +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())); }, } }) } +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]; 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); }, } }) } +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 __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); }, } }) } +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 = 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())); }, } }) } +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_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); }) } +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); }) } +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())); }, } }) } +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())); }, } }) } +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); }) } +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); }) } +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); }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 = 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())); }, } }) } +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 = 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); }) } +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 = 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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(222); let __v_1: G = G::from_u64(140); let __v_2: G = G::from_u64(16); let __v_3: G = G::from_u64(12); let __v_4: G = G::from_u64(34); let __v_5: G = G::from_u64(248); let __v_6: G = G::from_u64(42); let __v_7: G = G::from_u64(92); let __v_8: G = G::from_u64(53); let __v_9: G = G::from_u64(51); let __v_10: G = G::from_u64(198); let __v_11: G = G::from_u64(126); let __v_12: G = G::from_u64(67); let __v_13: G = G::from_u64(112); let __v_14: G = G::from_u64(103); let __v_15: G = G::from_u64(24); let __v_16: G = G::from_u64(19); let __v_17: G = G::from_u64(74); let __v_18: G = G::from_u64(111); let __v_19: G = G::from_u64(236); let __v_20: G = G::from_u64(93); let __v_21: G = G::from_u64(2); let __v_22: G = G::from_u64(57); let __v_23: G = G::from_u64(152); let __v_24: G = G::from_u64(208); let __v_25: G = G::from_u64(144); let __v_26: G = G::from_u64(223); let __v_27: G = G::from_u64(73); let __v_28: G = G::from_u64(52); 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_12, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_0, __v_24, __v_25, __v_26, __v_17, __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_180] = [__v_29]; 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(222); let __v_1: G = G::from_u64(140); let __v_2: G = G::from_u64(16); let __v_3: G = G::from_u64(12); let __v_4: G = G::from_u64(34); let __v_5: G = G::from_u64(248); let __v_6: G = G::from_u64(42); let __v_7: G = G::from_u64(92); let __v_8: G = G::from_u64(53); let __v_9: G = G::from_u64(51); let __v_10: G = G::from_u64(198); let __v_11: G = G::from_u64(126); let __v_12: G = G::from_u64(67); let __v_13: G = G::from_u64(112); let __v_14: G = G::from_u64(103); let __v_15: G = G::from_u64(24); let __v_16: G = G::from_u64(19); let __v_17: G = G::from_u64(74); let __v_18: G = G::from_u64(111); let __v_19: G = G::from_u64(236); let __v_20: G = G::from_u64(93); let __v_21: G = G::from_u64(2); let __v_22: G = G::from_u64(57); let __v_23: G = G::from_u64(152); let __v_24: G = G::from_u64(208); let __v_25: G = G::from_u64(144); let __v_26: G = G::from_u64(223); let __v_27: G = G::from_u64(73); let __v_28: G = G::from_u64(52); 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_12, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_0, __v_24, __v_25, __v_26, __v_17, __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_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(147); let __v_1: G = G::from_u64(175); let __v_2: G = G::from_u64(193); let __v_3: G = G::from_u64(205); let __v_4: G = G::from_u64(41); let __v_5: G = G::from_u64(140); let __v_6: G = G::from_u64(99); let __v_7: G = G::from_u64(96); let __v_8: G = G::from_u64(110); let __v_9: G = G::from_u64(95); let __v_10: G = G::from_u64(70); let __v_11: G = G::from_u64(141); let __v_12: G = G::from_u64(30); let __v_13: G = G::from_u64(89); let __v_14: G = G::from_u64(137); let __v_15: G = G::from_u64(171); let __v_16: G = G::from_u64(128); let __v_17: G = G::from_u64(210); let __v_18: G = G::from_u64(86); let __v_19: G = G::from_u64(233); let __v_20: G = G::from_u64(93); let __v_21: G = G::from_u64(7); let __v_22: G = G::from_u64(168); let __v_23: G = G::from_u64(100); let __v_24: G = G::from_u64(42); let __v_25: G = G::from_u64(136); let __v_26: G = G::from_u64(181); let __v_27: G = G::from_u64(198); let __v_28: G = G::from_u64(184); let __v_29: G = G::from_u64(88); let __v_30: G = G::from_u64(225); 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_181] = [__v_31]; 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(147); let __v_1: G = G::from_u64(175); let __v_2: G = G::from_u64(193); let __v_3: G = G::from_u64(205); let __v_4: G = G::from_u64(41); let __v_5: G = G::from_u64(140); let __v_6: G = G::from_u64(99); let __v_7: G = G::from_u64(96); let __v_8: G = G::from_u64(110); let __v_9: G = G::from_u64(95); let __v_10: G = G::from_u64(70); let __v_11: G = G::from_u64(141); let __v_12: G = G::from_u64(30); let __v_13: G = G::from_u64(89); let __v_14: G = G::from_u64(137); let __v_15: G = G::from_u64(171); let __v_16: G = G::from_u64(128); let __v_17: G = G::from_u64(210); let __v_18: G = G::from_u64(86); let __v_19: G = G::from_u64(233); let __v_20: G = G::from_u64(93); let __v_21: G = G::from_u64(7); let __v_22: G = G::from_u64(168); let __v_23: G = G::from_u64(100); let __v_24: G = G::from_u64(42); let __v_25: G = G::from_u64(136); let __v_26: G = G::from_u64(181); let __v_27: G = G::from_u64(198); let __v_28: G = G::from_u64(184); let __v_29: G = G::from_u64(88); let __v_30: G = G::from_u64(225); 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_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(119); let __v_1: G = G::from_u64(221); let __v_2: G = G::from_u64(64); let __v_3: G = G::from_u64(215); let __v_4: G = G::from_u64(182); let __v_5: G = G::from_u64(202); let __v_6: G = G::from_u64(49); let __v_7: G = G::from_u64(12); let __v_8: G = G::from_u64(197); let __v_9: G = G::from_u64(148); let __v_10: G = G::from_u64(102); let __v_11: G = G::from_u64(209); let __v_12: G = G::from_u64(242); let __v_13: G = G::from_u64(77); let __v_14: G = G::from_u64(244); let __v_15: G = G::from_u64(241); let __v_16: G = G::from_u64(128); let __v_17: G = G::from_u64(239); let __v_18: G = G::from_u64(80); let __v_19: G = G::from_u64(225); let __v_20: G = G::from_u64(176); let __v_21: G = G::from_u64(15); let __v_22: G = G::from_u64(216); let __v_23: G = G::from_u64(105); let __v_24: G = G::from_u64(132); let __v_25: G = G::from_u64(88); let __v_26: G = G::from_u64(205); let __v_27: G = G::from_u64(38); let __v_28: G = G::from_u64(144); let __v_29: G = G::from_u64(28); let __v_30: G = G::from_u64(93); 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_18, __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); }) } +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(119); let __v_1: G = G::from_u64(221); let __v_2: G = G::from_u64(64); let __v_3: G = G::from_u64(215); let __v_4: G = G::from_u64(182); let __v_5: G = G::from_u64(202); let __v_6: G = G::from_u64(49); let __v_7: G = G::from_u64(12); let __v_8: G = G::from_u64(197); let __v_9: G = G::from_u64(148); let __v_10: G = G::from_u64(102); let __v_11: G = G::from_u64(209); let __v_12: G = G::from_u64(242); let __v_13: G = G::from_u64(77); let __v_14: G = G::from_u64(244); let __v_15: G = G::from_u64(241); let __v_16: G = G::from_u64(128); let __v_17: G = G::from_u64(239); let __v_18: G = G::from_u64(80); let __v_19: G = G::from_u64(225); let __v_20: G = G::from_u64(176); let __v_21: G = G::from_u64(15); let __v_22: G = G::from_u64(216); let __v_23: G = G::from_u64(105); let __v_24: G = G::from_u64(132); let __v_25: G = G::from_u64(88); let __v_26: G = G::from_u64(205); let __v_27: G = G::from_u64(38); let __v_28: G = G::from_u64(144); let __v_29: G = G::from_u64(28); let __v_30: G = G::from_u64(93); 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_18, __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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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 = 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); }) } +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(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); }) } +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(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); }) } +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); }, } }, } }, } }, } }, } }) } +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); }) } +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); }) } +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 __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); }, } }, } }, } }, } }, } }, } }) } +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); }, } }, } }) } +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); }, } }) } +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); }, } }) } +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(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); }) } +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(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); }) } +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(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); }) } +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 = 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); }) } +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 = 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); }) } +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); }) } +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 = 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); }, } }, } }, } }) } +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 = 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); }, } }) } +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())); }, } }) } +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 __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())); }, } }, } }) } +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); }, } }, } }) } +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); }, } }) } +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); }, } }, } }, } }) } +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 = 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())); }, } }) } +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 = 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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(97); let __v_1: G = G::from_u64(110); let __v_2: G = G::from_u64(238); let __v_3: G = G::from_u64(176); let __v_4: G = G::from_u64(115); let __v_5: G = G::from_u64(95); let __v_6: G = G::from_u64(147); let __v_7: G = G::from_u64(221); let __v_8: G = G::from_u64(16); let __v_9: G = G::from_u64(137); let __v_10: G = G::from_u64(27); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(187); let __v_13: G = G::from_u64(101); let __v_14: G = G::from_u64(157); let __v_15: G = G::from_u64(216); let __v_16: G = G::from_u64(4); let __v_17: G = G::from_u64(24); let __v_18: G = G::from_u64(166); let __v_19: G = G::from_u64(232); let __v_20: G = G::from_u64(74); let __v_21: G = G::from_u64(156); let __v_22: G = G::from_u64(225); let __v_23: G = G::from_u64(49); let __v_24: G = G::from_u64(62); let __v_25: G = G::from_u64(203); let __v_26: G = G::from_u64(65); let __v_27: G = G::from_u64(173); let __v_28: G = G::from_u64(199); let __v_29: G = G::from_u64(98); let __v_30: G = G::from_u64(58); 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_3, __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); }) } +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(97); let __v_1: G = G::from_u64(110); let __v_2: G = G::from_u64(238); let __v_3: G = G::from_u64(176); let __v_4: G = G::from_u64(115); let __v_5: G = G::from_u64(95); let __v_6: G = G::from_u64(147); let __v_7: G = G::from_u64(221); let __v_8: G = G::from_u64(16); let __v_9: G = G::from_u64(137); let __v_10: G = G::from_u64(27); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(187); let __v_13: G = G::from_u64(101); let __v_14: G = G::from_u64(157); let __v_15: G = G::from_u64(216); let __v_16: G = G::from_u64(4); let __v_17: G = G::from_u64(24); let __v_18: G = G::from_u64(166); let __v_19: G = G::from_u64(232); let __v_20: G = G::from_u64(74); let __v_21: G = G::from_u64(156); let __v_22: G = G::from_u64(225); let __v_23: G = G::from_u64(49); let __v_24: G = G::from_u64(62); let __v_25: G = G::from_u64(203); let __v_26: G = G::from_u64(65); let __v_27: G = G::from_u64(173); let __v_28: G = G::from_u64(199); let __v_29: G = G::from_u64(98); let __v_30: G = G::from_u64(58); 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_3, __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(47); let __v_1: G = G::from_u64(78); let __v_2: G = G::from_u64(3); let __v_3: G = G::from_u64(38); let __v_4: G = G::from_u64(117); let __v_5: G = G::from_u64(185); let __v_6: G = G::from_u64(21); let __v_7: G = G::from_u64(191); let __v_8: G = G::from_u64(212); let __v_9: G = G::from_u64(76); let __v_10: G = G::from_u64(32); let __v_11: G = G::from_u64(153); let __v_12: G = G::from_u64(180); let __v_13: G = G::from_u64(28); let __v_14: G = G::from_u64(129); let __v_15: G = G::from_u64(113); let __v_16: G = G::from_u64(194); let __v_17: G = G::from_u64(89); let __v_18: G = G::from_u64(236); let __v_19: G = G::from_u64(66); let __v_20: G = G::from_u64(244); let __v_21: G = G::from_u64(181); let __v_22: G = G::from_u64(226); let __v_23: G = G::from_u64(79); let __v_24: G = G::from_u64(221); let __v_25: G = G::from_u64(223); let __v_26: G = G::from_u64(192); let __v_27: G = G::from_u64(63); let __v_28: G = G::from_u64(229); let __v_29: G = G::from_u64(115); 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_11, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_10, __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_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(47); let __v_1: G = G::from_u64(78); let __v_2: G = G::from_u64(3); let __v_3: G = G::from_u64(38); let __v_4: G = G::from_u64(117); let __v_5: G = G::from_u64(185); let __v_6: G = G::from_u64(21); let __v_7: G = G::from_u64(191); let __v_8: G = G::from_u64(212); let __v_9: G = G::from_u64(76); let __v_10: G = G::from_u64(32); let __v_11: G = G::from_u64(153); let __v_12: G = G::from_u64(180); let __v_13: G = G::from_u64(28); let __v_14: G = G::from_u64(129); let __v_15: G = G::from_u64(113); let __v_16: G = G::from_u64(194); let __v_17: G = G::from_u64(89); let __v_18: G = G::from_u64(236); let __v_19: G = G::from_u64(66); let __v_20: G = G::from_u64(244); let __v_21: G = G::from_u64(181); let __v_22: G = G::from_u64(226); let __v_23: G = G::from_u64(79); let __v_24: G = G::from_u64(221); let __v_25: G = G::from_u64(223); let __v_26: G = G::from_u64(192); let __v_27: G = G::from_u64(63); let __v_28: G = G::from_u64(229); let __v_29: G = G::from_u64(115); 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_11, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_10, __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_225] = [__v_30]; 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(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); }) } +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 = 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); }) } +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); }) } +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); }) } +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 = 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); }, } }, } }, } }, } }, } }, } }, } }) } +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); }, } }, } }, } }, } }, } }, } }, } }) } +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 = 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); }, } }, } }) } +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); }, } }, } }) } +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 = 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())); }, } }) } +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); }) } +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 = 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())); }, } }) } +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 = 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())); }, } }) } +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 = 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())); }, } }, } }) } +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 = 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); }) } +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())); }, } }) } +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 __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); }, } }) } +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 = 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); }, } }) } +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); }) } +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 = 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); }) } +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 __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); }, } }) } +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 __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); }, } }) } +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 = 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); }, } }) } +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); }, } }) } +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); }, } }) } +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 = 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); }) } +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); }, } }, } }, } }) } +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); }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }) } +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 __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); }) } +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 = 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); }, } }) } +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 = 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); }, } }) } +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 = 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); }) } +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); }, } }) } +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 __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); }) } +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 __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); }, } }, } }) } +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_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); }, } }, } }) } +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); }, } }) } +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); }, } }, } }) } +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 __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); }, } }, } }) } +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_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); }, } }, } }, } }) } +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); }, } }, } }) } +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 __loaded: [G; 3] = { let __base = 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())); }, } }) } +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); }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }, } }) } +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); }, } }) } +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 __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); }, } }) } +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); }, } }, } }) } +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_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); }, } }) } +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); }, } }) } +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 __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())); }, } }, } }) } +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); }, } }, } }) } +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); }, } }, } }, } }) } +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); }, } }, } }) } +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 = 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); }) } +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())); }, } }, } }) } +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]; 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())); }, } }, } }) } +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 = 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); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }, } }) } +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); }, } }) } +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]; 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); }, } }) } +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())); }, } }) } +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())); }, } }) } +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]; 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); }, } }) } +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); }, } }) } +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 __v_1: G = inp[1]; let __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())); }, } }) } +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); }, } }) } +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); }) } +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 __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())); }, } }) } +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 __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); }) } +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]; 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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; 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); }, } }, } }) } +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 __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())); }, } }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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())); }, } }, } }) } +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 = 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())); }, } }, } }) } +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())); }, } }, } }) } +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 __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())); }, } }, } }) } +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 = 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())); }, } }) } +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); }) } +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 __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); }) } +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 __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); }) } +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 __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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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() { 0u64 => { let __loaded: [G; 3] = { let __base = 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())); }, } }) } +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 = 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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())); }, } }) } +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 __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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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]; 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); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __loaded: [G; 3] = { let __base = 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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; 3] = { let __base = 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())); }, } }) } +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(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())); }, } }) } +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 __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())); }, } }) } +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 = 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 = 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); }) } +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_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())); }, } }) } +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 __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())); }, } }) } +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 __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); }, } }) } +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 __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())); }, } }) } +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())); }, } }, } }) } +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 = 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); }, } }) } +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 __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())); }, } }) } +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 = 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); }, } }) } +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 = 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); }, } }) } +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_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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); }, } }) } +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 __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 __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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 = 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())); }, } }) } +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]; let __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 = 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); }) } +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 = { 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())); }, } }) } +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]; 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); }, } }) } +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 = { 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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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]; 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); }) } +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]; 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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]; 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())); }, } }, } }) } +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]; 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())); }, } }, } }) } +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 __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); }, } }) } +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 __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 __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); }, } }) } +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 = 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); }, } }, } }) } +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]; 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())); }, } }, } }) } +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]; let __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 __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())); }, } }) } +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 __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); }) } +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]; 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())); }, } }, } }) } +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 __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }) } +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 __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())); }, } }) } +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 __loaded: [G; 4] = { let __base = 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())); }, } }) } +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_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())); }, } }) } +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 __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); }) } +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 __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())); }, } }, } }) } +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 = 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())); }, } }) } +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 __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 __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); }) } +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); }, } }) } +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 = 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); }, } }) } +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 = 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); }, } }) } +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 = inp[0]; let __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); }, } }, } }) } +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(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); }) } +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(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); }) } +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(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); }) } +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); }) } +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 = 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); }) } +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 = 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); }) } +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 __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); }, } }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 __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())); }, } }) } +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 __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); }, } }, } }) } +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())); }, } }) } +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); }, } }, } }, } }, } }, } }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }) } +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); }, } }, } }) } +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 __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); }, } }, } }) } +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 = 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); }, } }) } +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 __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); }, } }, } }) } +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 = 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); }, } }) } +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); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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); }, } }) } +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); }, } }) } +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); }) } +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 = 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); }, } }) } +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 __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); }, } }, } }, } }) } +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); }, } }) } +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())); }, } }) } +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())); }, } }) } +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 = 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); }, } }, } }) } +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 = (__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); }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }) } +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 __v_2: G = 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); }, } }, } }) } +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]; 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); }, } }, } }) } +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() { 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); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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; 3] = { let __base = 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())); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 = 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); }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 __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); }, } }) } +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 = 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); }, } }) } +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 __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); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 = 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); }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }) } +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 __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); }, } }, } }) } +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_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); }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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())); }, } }) } +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 __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())); }, } }) } +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 __loaded: [G; 4] = { let __base = 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())); }, } }) } +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 __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())); }, } }, } }) } +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]; 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())); }, } }, } }) } +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 = 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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); }, } }, } }) } +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 __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); }, } }) } +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 __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); }, } }) } +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 __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); }, } }) } +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); }, } }) } +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 = 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())); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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); }, } }) } +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 = 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); }, } }, } }, } }) } +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_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); }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }, } }) } +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 __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); }, } }, } }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 = 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); }, } }, } }, } }, } }, } }, } }, } }) } +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 __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); }, } }, } }) } +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); }, } }, } }) } +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); }, } }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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); }, } }, } }) } +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); }, } }, } }, } }, } }) } +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 __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); }, } }, } }, } }, } }, } }, } }, } }) } +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 __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); }, } }) } +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 __v_3: G = 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); }, } }, } }) } +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 __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); }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }, } }) } +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 __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); }, } }) } +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 __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); }, } }) } +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_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); }, } }) } +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 __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); }, } }) } +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); }, } }) } +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 __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); }) } +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())); }, } }) } +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]; 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); }, } }, } }, } }, } }, } }) } +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); }, } }) } +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 __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); }, } }, } }, } }, } }) } +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 __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); }, } }) } +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 __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); }, } }) } +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_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); }, } }) } +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); }, } }, } }, } }) } +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); }, } }, } }, } }) } +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); }, } }, } }) } +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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); }, } }) } +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 __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); }, } }) } +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 __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); }, } }) } +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 __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())); }, } }, } }, } }) } +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); }, } }) } +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); }, } }) } +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 __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); }, } }) } +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 = 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); }, } }) } +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 = 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())); }, } }) } +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 __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); }) } +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); }) } +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())); }, } }) } +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 __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); }) } +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())); }, } }) } +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 __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); }, } }, } }) } +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); }, } }, } }) } +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 __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())); }, } }) } +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 __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); }) } +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 = 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); }, } }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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]; 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())); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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]; 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); }, } }, } }) } +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); }, } }) } +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); }, } }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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 = 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())); }, } }) } +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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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(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); }) } +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 = 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); }) } +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 = 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); }) } +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); }) } +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 __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); }, } }, } }, } }, } }, } }, } }) } +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); }, } }, } }, } }) } +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); }, } }) } +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); }) } +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 = 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); }, } }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }, } }) } +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 __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())); }, } }) } +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 = 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())); }, } }) } +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 __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); }, } }) } +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); }, } }, } }) } +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); }, } }) } +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 = inp[0]; let __v_1: G = inp[1]; let __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); }, } }) } +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())); }, } }, } }) } +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); }, } }) } +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 = 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); }) } +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 = 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); }) } +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); }) } +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); }, } }) } +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); }) } +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); }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = 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); }) } +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; 4] = { let __base = 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())); }, } }) } +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); }, } }, } }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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]; 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())); }, } }) } +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 __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); }, } }) } +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())); }, } }) } +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); }) } +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())); }, } }) } +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 __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); }, } }) } +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())); }, } }) } +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]; 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); }, } }, } }) } +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 __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())); }, } }) } +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())); }, } }) } +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]; 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); }, } }) } +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); }, } }) } +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); }, } }) } +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); }, } }) } +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(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); }) } +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); }) } +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); }, } }) } +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 = 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); }) } +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 = 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())); }, } }) } +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())); }, } }) } +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 __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); }, } }) } +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 __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); }) } +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 __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); }, } }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 = 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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 __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); }, } }, } }) } +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())); }, } }) } +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())); }, } }) } +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]; 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); }, } }) } +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())); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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 = 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); }) } +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); }) } +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]; 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); }, } }, } }) } +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 __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())); }, } }) } +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 __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); }) } +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())); }, } }, } }) } +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]; 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())); }, } }, } }) } +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]; 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())); }, } }, } }) } +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 __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())); }, } }) } +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())); }, } }) } +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 __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())); }, } }, } }) } +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 = 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); }) } +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 = 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())); }, } }, } }) } +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); }, } }) } +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())); }, } }, } }) } +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); }, } }) } +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 __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); }) } +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_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())); }, } }) } +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); }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }, } }, } }) } +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 = (__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())); }, } }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }, } }, } }) } +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 = (__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())); }, } }, } }) } +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 __loaded: [G; 4] = { let __base = 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); }, } }) } +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 = 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); }) } +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 = (__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); }) } +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 __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())); }, } }, } }) } +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); }, } }) } +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); }, } }) } +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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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); }, } }, } }, } }) } +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 __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); }, } }, } }) } +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 = (__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); }, } }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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); }, } }) } +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 __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); }, } }, } }, } }) } +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 __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); }, } }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; 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); }, } }) } +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 __v_2: G = 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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); }, } }) } +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 __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); }, } }, } }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 = (__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())); }, } }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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); }, } }) } +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 __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); }, } }, } }) } +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 __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())); }, } }) } +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 = 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); }, } }) } +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); }, } }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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]; 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); }, } }, } }) } +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 __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())); }, } }, } }) } +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]; 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); }, } }, } }, } }) } +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 = 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); }, } }) } +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 __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())); }, } }) } +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); }, } }) } +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 __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); }, } }) } +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 __loaded: [G; 3] = { let __base = 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())); }, } }) } +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); }, } }, } }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 = 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); }, } }) } +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 = (__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); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __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); }) } +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 = 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); }) } +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 = (__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); }, } }) } +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())); }, } }) } +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); }, } }) } +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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __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())); }, } }) } +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())); }, } }) } +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 __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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); }) } +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 = (__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())); }, } }, } }) } +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 __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); }, } }, } }) } +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())); }, } }) } +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 __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __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())); }, } }) } +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 __v_8: G = inp[8]; let __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); }) } +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 __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())); }, } }) } +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 __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); }, } }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 __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); }) } +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]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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())); }, } }, } }) } +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 __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); }) } +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]; 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())); }, } }) } +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]; 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); }, } }, } }) } +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); }, } }) } +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())); }, } }, } }, } }) } +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 __v_8: G = inp[8]; let __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); }) } +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); }) } +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); }, } }) } +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]; 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())); }, } }) } +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 = 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())); }, } }) } +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); }, } }) } +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); }, } }) } +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 = 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); }) } +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); }, } }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }, } }) } +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 = 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())); }, } }) } +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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; 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())); }, } }) } +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())); }, } }) } +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); }, } }) } +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 __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())); }, } }) } +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); }, } }, } }) } +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())); }, } }) } +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 = 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); }) } +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; 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); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }) } +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 = 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())); }, } }) } +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); }, } }, } }) } +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())); }, } }) } +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 __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); }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }) } +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 __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); }) } +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); }) } +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())); }, } }) } +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); }) } +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())); }, } }) } +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); }) } +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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __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); }, } }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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); }) } +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); }, } }) } +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())); }, } }) } +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 __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())); }, } }) } +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 = 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); }, } }) } +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_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); }, } }) } +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); }, } }) } +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_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())); }, } }, } }) } +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())); }, } }, } }) } +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); }, } }) } +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); }, } }) } +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); }) } +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 = 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); }) } +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); }, } }) } +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); }, } }) } +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_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())); }, } }) } +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 = 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); }) } +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); }, } }) } +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())); }, } }) } +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); }) } +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())); }, } }) } +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 => { 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())); }, } }) } +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]; 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())); }, } }) } +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 __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())); }, } }) } +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 => { 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())); }, } }) } +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 __v_10: G = inp[10]; let __v_11: G = 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())); }, } }) } +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 __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())); }, } }) } +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]; 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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __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())); }, } }) } +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 __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())); }, } }) } +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 __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); }, } }, } }) } +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; 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())); }, } }) } +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]; 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())); }, } }) } +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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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())); }, } }) } +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 __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())); }, } }) } +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 __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = 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())); }, } }, } }) } +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); }) } +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())); }, } }) } +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); }) } +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 __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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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())); }, } }) } +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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; 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())); }, } }) } +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 = 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); }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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 = 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())); }, } }) } +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 = 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())); }, } }) } +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 = 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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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 __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())); }, } }) } +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 __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())); }, } }, } }) } +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())); }, } }, } }) } +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; 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())); }, } }) } +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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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())); }, } }) } +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]; 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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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())); }, } }) } +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); }, } }) } +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); }, } }, } }) } +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/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 43d2876eb..63c5a874a 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -12,1025 +12,1025 @@ use aiur::execute::{ExecError, IOBuffer, QueryRecord}; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; -fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_0(inp: [G; IN_0], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __ret: [G; OUT_0] = [__v_2]; record.function_queries[0].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_1: usize = 3; const IN_1: usize = 3; const OUT_1: usize = 1; -fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_4]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, (&__args[..]))?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_9]; record.function_queries[1].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_1(inp: [G; IN_1], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_4]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(1, &__args[..])?) { [G::ZERO; OUT_1] } else { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[1].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_7: G = __io_read[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_1] = [__v_9]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_2: usize = 8; const IN_2: usize = 8; const OUT_2: usize = 1; -fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_2(inp: [G; IN_2], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_8]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_3: usize = 8; const IN_3: usize = 8; const OUT_3: usize = 4; -fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __u32_sum: u128 = (u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_13: G = (__v_12 * __v_12); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_3] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[3].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_3(inp: [G; IN_3], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __u32_sum: u128 = u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); let __v_9: G = G::from_u8(__u32_bytes[1]); let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_13: G = __v_12 * __v_12; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_3] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_4: usize = 12; const IN_4: usize = 12; const OUT_4: usize = 4; -fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); let __v_13: G = G::from_u8(__u32_bytes[1]); let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_u64(2); let __v_20: G = (__v_16 - __v_19); let __v_21: G = (__v_18 * __v_20); let __v_22: G = (__v_16 * __v_21); let __v_23: G = G::from_u64(0); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_4] = [__v_12, __v_13, __v_14, __v_15]; record.function_queries[4].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_4(inp: [G; IN_4], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __u32_sum: u128 = (u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24))) + u128::from((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); let __v_13: G = G::from_u8(__u32_bytes[1]); let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_17: G = G::from_u64(1); let __v_18: G = __v_16 - __v_17; let __v_19: G = G::from_u64(2); let __v_20: G = __v_16 - __v_19; let __v_21: G = __v_18 * __v_20; let __v_22: G = __v_16 * __v_21; let __v_23: G = G::from_u64(0); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_4] = [__v_12, __v_13, __v_14, __v_15]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_5: usize = 8; const IN_5: usize = 8; const OUT_5: usize = 4; -fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_5(inp: [G; IN_5], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_value(__v_0, __v_4, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_6: usize = 4; const IN_6: usize = 4; const OUT_6: usize = 4; -fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[6].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_6(inp: [G; IN_6], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_7: usize = 4; const IN_7: usize = 4; const OUT_7: usize = 4; -fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_7] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[7].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_7(inp: [G; IN_7], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_7] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[7].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_8: usize = 8; const IN_8: usize = 8; const OUT_8: usize = 4; -fn aiur_fn_8(inp: [G; IN_8], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); let __v_17: G = (__v_10 + __v_13); let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[8].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_8(inp: [G; IN_8], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split7_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split7_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split7_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split7_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_8 + __v_11; let __v_17: G = __v_10 + __v_13; let __v_18: G = __v_12 + __v_15; let __v_19: G = __v_14 + __v_9; let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[8].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_9: usize = 8; const IN_9: usize = 8; const OUT_9: usize = 4; -fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_0), (&__v_4)) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_1), (&__v_5)) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_2), (&__v_6)) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_3), (&__v_7)) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); let __v_17: G = (__v_12 + __v_15); let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_9] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[9].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_9(inp: [G; IN_9], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_0, &__v_4) } else { aiur::execute::bytes2_xor_split4_value(__v_0, __v_4, record) }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_split4_value(__v_1, __v_5, record) }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_split4_value(__v_2, __v_6, record) }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_3, &__v_7) } else { aiur::execute::bytes2_xor_split4_value(__v_3, __v_7, record) }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = __v_10 + __v_13; let __v_17: G = __v_12 + __v_15; let __v_18: G = __v_14 + __v_9; let __v_19: G = __v_8 + __v_11; let __ret: [G; OUT_9] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[9].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_10: usize = 16; const IN_10: usize = 16; const OUT_10: usize = 1; -fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = (__v_0 - __v_8); let __v_17: G = (__v_1 - __v_9); let __v_18: G = (__v_2 - __v_10); let __v_19: G = (__v_3 - __v_11); let __v_20: G = (__v_4 - __v_12); let __v_21: G = (__v_5 - __v_13); let __v_22: G = (__v_6 - __v_14); let __v_23: G = (__v_7 - __v_15); match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_10(inp: [G; IN_10], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = __v_0 - __v_8; let __v_17: G = __v_1 - __v_9; let __v_18: G = __v_2 - __v_10; let __v_19: G = __v_3 - __v_11; let __v_20: G = __v_4 - __v_12; let __v_21: G = __v_5 - __v_13; let __v_22: G = __v_6 - __v_14; let __v_23: G = __v_7 - __v_15; match __v_16.as_canonical_u64() { 0u64 => { match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_10] = [__v_24]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_11: usize = 8; const IN_11: usize = 8; const OUT_11: usize = 8; -fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_7 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_6 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_11(inp: [G; IN_11], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { 255u64 => { match __v_2.as_canonical_u64() { 255u64 => { match __v_3.as_canonical_u64() { 255u64 => { match __v_4.as_canonical_u64() { 255u64 => { match __v_5.as_canonical_u64() { 255u64 => { match __v_6.as_canonical_u64() { 255u64 => { match __v_7.as_canonical_u64() { 255u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_7 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_6 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_5 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 + __v_9; let __ret: [G; OUT_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_0 + __v_8; let __ret: [G; OUT_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_12: usize = 8; const IN_12: usize = 8; const OUT_12: usize = 1; -fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_1); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_2); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_3); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_4); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_5); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_6); let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); let __v_23: G = (__v_14 + __v_22); let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_12] = [__v_26]; record.function_queries[12].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_12(inp: [G; IN_12], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); } let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_1; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_2; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_3; let __v_15: G = G::from_u64(4294967296); let __v_16: G = __v_15 * __v_4; let __v_17: G = G::from_u64(1099511627776); let __v_18: G = __v_17 * __v_5; let __v_19: G = G::from_u64(281474976710656); let __v_20: G = __v_19 * __v_6; let __v_21: G = __v_18 + __v_20; let __v_22: G = __v_16 + __v_21; let __v_23: G = __v_14 + __v_22; let __v_24: G = __v_12 + __v_23; let __v_25: G = __v_10 + __v_24; let __v_26: G = __v_0 + __v_25; let __ret: [G; OUT_12] = [__v_26]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_13: usize = 8; const IN_13: usize = 8; const OUT_13: usize = 1; -fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(256); let __v_9: G = (__v_8 * __v_1); let __v_10: G = G::from_u64(65536); let __v_11: G = (__v_10 * __v_2); let __v_12: G = G::from_u64(16777216); let __v_13: G = (__v_12 * __v_3); let __v_14: G = G::from_u64(4294967296); let __v_15: G = (__v_14 * __v_4); let __v_16: G = G::from_u64(1099511627776); let __v_17: G = (__v_16 * __v_5); let __v_18: G = G::from_u64(281474976710656); let __v_19: G = (__v_18 * __v_6); let __v_20: G = G::from_u64(72057594037927936); let __v_21: G = (__v_20 * __v_7); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_17 + __v_22); let __v_24: G = (__v_15 + __v_23); let __v_25: G = (__v_13 + __v_24); let __v_26: G = (__v_11 + __v_25); let __v_27: G = (__v_9 + __v_26); let __v_28: G = (__v_0 + __v_27); let __ret: [G; OUT_13] = [__v_28]; record.function_queries[13].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_13(inp: [G; IN_13], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(256); let __v_9: G = __v_8 * __v_1; let __v_10: G = G::from_u64(65536); let __v_11: G = __v_10 * __v_2; let __v_12: G = G::from_u64(16777216); let __v_13: G = __v_12 * __v_3; let __v_14: G = G::from_u64(4294967296); let __v_15: G = __v_14 * __v_4; let __v_16: G = G::from_u64(1099511627776); let __v_17: G = __v_16 * __v_5; let __v_18: G = G::from_u64(281474976710656); let __v_19: G = __v_18 * __v_6; let __v_20: G = G::from_u64(72057594037927936); let __v_21: G = __v_20 * __v_7; let __v_22: G = __v_19 + __v_21; let __v_23: G = __v_17 + __v_22; let __v_24: G = __v_15 + __v_23; let __v_25: G = __v_13 + __v_24; let __v_26: G = __v_11 + __v_25; let __v_27: G = __v_9 + __v_26; let __v_28: G = __v_0 + __v_27; let __ret: [G; OUT_13] = [__v_28]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_14: usize = 8; const IN_14: usize = 8; const OUT_14: usize = 1; -fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_4 + __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = (__v_2 + __v_3); let __v_15: G = (__v_1 + __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_bool((__v_16 == G::ZERO)); let __v_18: G = G::from_u64(1); let __v_19: G = (__v_18 - __v_17); let __v_20: G = (__v_13 * __v_19); let __v_21: G = (__v_18 - __v_20); let __ret: [G; OUT_14] = [__v_21]; record.function_queries[14].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_14(inp: [G; IN_14], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = __v_7 - __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_5 + __v_10; let __v_12: G = __v_4 + __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_2 + __v_3; let __v_15: G = __v_1 + __v_14; let __v_16: G = __v_0 + __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = G::from_u64(1); let __v_19: G = __v_18 - __v_17; let __v_20: G = __v_13 * __v_19; let __v_21: G = __v_18 - __v_20; let __ret: [G; OUT_14] = [__v_21]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_15: usize = 1; const IN_15: usize = 1; const OUT_15: usize = 8; -fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); let __v_3: G = G::from_u8(__gb[2]); let __v_4: G = G::from_u8(__gb[3]); let __v_5: G = G::from_u8(__gb[4]); let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_2); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_3); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_4); let __v_15: G = G::from_u64(4294967296); let __v_16: G = (__v_15 * __v_5); let __v_17: G = G::from_u64(1099511627776); let __v_18: G = (__v_17 * __v_6); let __v_19: G = G::from_u64(281474976710656); let __v_20: G = (__v_19 * __v_7); let __v_21: G = G::from_u64(72057594037927936); let __v_22: G = (__v_21 * __v_8); let __v_23: G = (__v_20 + __v_22); let __v_24: G = (__v_18 + __v_23); let __v_25: G = (__v_16 + __v_24); let __v_26: G = (__v_14 + __v_25); let __v_27: G = (__v_12 + __v_26); let __v_28: G = (__v_10 + __v_27); let __v_29: G = (__v_1 + __v_28); if (__v_29 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_30: G = G::from_u64(1020); let __v_31: G = (__v_8 - __v_30); let __v_32: G = (__v_7 + __v_31); let __v_33: G = (__v_6 + __v_32); let __v_34: G = (__v_5 + __v_33); let __v_35: G = G::from_bool((__v_34 == G::ZERO)); let __v_36: G = (__v_3 + __v_4); let __v_37: G = (__v_2 + __v_36); let __v_38: G = (__v_1 + __v_37); let __v_39: G = G::from_bool((__v_38 == G::ZERO)); let __v_40: G = G::from_u64(1); let __v_41: G = (__v_40 - __v_39); let __v_42: G = (__v_35 * __v_41); let __v_43: G = (__v_40 - __v_42); if (__v_43 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[15].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_15(inp: [G; IN_15], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); let __v_3: G = G::from_u8(__gb[2]); let __v_4: G = G::from_u8(__gb[3]); let __v_5: G = G::from_u8(__gb[4]); let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_2; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_3; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_4; let __v_15: G = G::from_u64(4294967296); let __v_16: G = __v_15 * __v_5; let __v_17: G = G::from_u64(1099511627776); let __v_18: G = __v_17 * __v_6; let __v_19: G = G::from_u64(281474976710656); let __v_20: G = __v_19 * __v_7; let __v_21: G = G::from_u64(72057594037927936); let __v_22: G = __v_21 * __v_8; let __v_23: G = __v_20 + __v_22; let __v_24: G = __v_18 + __v_23; let __v_25: G = __v_16 + __v_24; let __v_26: G = __v_14 + __v_25; let __v_27: G = __v_12 + __v_26; let __v_28: G = __v_10 + __v_27; let __v_29: G = __v_1 + __v_28; if (__v_29 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_30: G = G::from_u64(1020); let __v_31: G = __v_8 - __v_30; let __v_32: G = __v_7 + __v_31; let __v_33: G = __v_6 + __v_32; let __v_34: G = __v_5 + __v_33; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = __v_3 + __v_4; let __v_37: G = __v_2 + __v_36; let __v_38: G = __v_1 + __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = G::from_u64(1); let __v_41: G = __v_40 - __v_39; let __v_42: G = __v_35 * __v_41; let __v_43: G = __v_40 - __v_42; if (__v_43 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[15].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_16: usize = 1; const IN_16: usize = 1; const OUT_16: usize = 1; -fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = aiur::execute::g_inverse_value(__v_0); let __v_2: G = (__v_0 * __v_1); let __v_3: G = G::from_u64(1); let __v_4: G = (__v_2 - __v_3); let __v_5: G = (__v_0 * __v_4); let __v_6: G = G::from_u64(0); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_7: G = (__v_1 * __v_4); if (__v_7 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_16] = [__v_1]; record.function_queries[16].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_16(inp: [G; IN_16], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = aiur::execute::g_inverse_value(__v_0); let __v_2: G = __v_0 * __v_1; let __v_3: G = G::from_u64(1); let __v_4: G = __v_2 - __v_3; let __v_5: G = __v_0 * __v_4; let __v_6: G = G::from_u64(0); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_7: G = __v_1 * __v_4; if (__v_7 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_16] = [__v_1]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_17: usize = 4; const IN_17: usize = 4; const OUT_17: usize = 2; -fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 + __v_2); let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_17] = [__v_4, __v_5]; record.function_queries[17].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_17(inp: [G; IN_17], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 + __v_2; let __v_5: G = __v_1 + __v_3; let __ret: [G; OUT_17] = [__v_4, __v_5]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_18: usize = 4; const IN_18: usize = 4; const OUT_18: usize = 2; -fn aiur_fn_18(inp: [G; IN_18], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_18] = [__v_4, __v_5]; record.function_queries[18].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_18(inp: [G; IN_18], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 - __v_2; let __v_5: G = __v_1 - __v_3; let __ret: [G; OUT_18] = [__v_4, __v_5]; record.function_queries[18].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_19: usize = 2; const IN_19: usize = 2; const OUT_19: usize = 2; -fn aiur_fn_19(inp: [G; IN_19], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = (__v_2 - __v_0); let __v_4: G = (__v_2 - __v_1); let __ret: [G; OUT_19] = [__v_3, __v_4]; record.function_queries[19].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_19(inp: [G; IN_19], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __v_3: G = __v_2 - __v_0; let __v_4: G = __v_2 - __v_1; let __ret: [G; OUT_19] = [__v_3, __v_4]; record.function_queries[19].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_20: usize = 4; const IN_20: usize = 4; const OUT_20: usize = 2; -fn aiur_fn_20(inp: [G; IN_20], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_1 * __v_3); let __v_7: G = (__v_5 * __v_6); let __v_8: G = (__v_4 + __v_7); let __v_9: G = (__v_0 * __v_3); let __v_10: G = (__v_1 * __v_2); let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_20] = [__v_8, __v_11]; record.function_queries[20].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_20(inp: [G; IN_20], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 * __v_2; let __v_5: G = G::from_u64(7); let __v_6: G = __v_1 * __v_3; let __v_7: G = __v_5 * __v_6; let __v_8: G = __v_4 + __v_7; let __v_9: G = __v_0 * __v_3; let __v_10: G = __v_1 * __v_2; let __v_11: G = __v_9 + __v_10; let __ret: [G; OUT_20] = [__v_8, __v_11]; record.function_queries[20].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_21: usize = 2; const IN_21: usize = 2; const OUT_21: usize = 2; -fn aiur_fn_21(inp: [G; IN_21], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 * __v_0); let __v_3: G = G::from_u64(7); let __v_4: G = (__v_1 * __v_1); let __v_5: G = (__v_3 * __v_4); let __v_6: G = (__v_2 - __v_5); let __v_7: G = aiur::execute::g_inverse_value(__v_6); let __v_8: G = (__v_6 * __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 - __v_9); let __v_11: G = (__v_6 * __v_10); let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_13: G = (__v_7 * __v_10); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_14: G = (__v_0 * __v_7); let __v_15: G = (__v_12 - __v_1); let __v_16: G = (__v_15 * __v_7); let __ret: [G; OUT_21] = [__v_14, __v_16]; record.function_queries[21].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_21(inp: [G; IN_21], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = __v_0 * __v_0; let __v_3: G = G::from_u64(7); let __v_4: G = __v_1 * __v_1; let __v_5: G = __v_3 * __v_4; let __v_6: G = __v_2 - __v_5; let __v_7: G = aiur::execute::g_inverse_value(__v_6); let __v_8: G = __v_6 * __v_7; let __v_9: G = G::from_u64(1); let __v_10: G = __v_8 - __v_9; let __v_11: G = __v_6 * __v_10; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_13: G = __v_7 * __v_10; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } let __v_14: G = __v_0 * __v_7; let __v_15: G = __v_12 - __v_1; let __v_16: G = __v_15 * __v_7; let __ret: [G; OUT_21] = [__v_14, __v_16]; record.function_queries[21].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_22: usize = 4; const IN_22: usize = 4; const OUT_22: usize = 2; -fn aiur_fn_22(inp: [G; IN_22], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_2 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_3 * __v_3); let __v_7: G = (__v_5 * __v_6); let __v_8: G = (__v_4 - __v_7); let __v_9: G = aiur::execute::g_inverse_value(__v_8); let __v_10: G = (__v_8 * __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 - __v_11); let __v_13: G = (__v_8 * __v_12); let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_9 * __v_12); if (__v_15 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_16: G = (__v_2 * __v_9); let __v_17: G = (__v_14 - __v_3); let __v_18: G = (__v_17 * __v_9); let __v_19: G = (__v_0 * __v_16); let __v_20: G = (__v_1 * __v_18); let __v_21: G = (__v_5 * __v_20); let __v_22: G = (__v_19 + __v_21); let __v_23: G = (__v_0 * __v_18); let __v_24: G = (__v_1 * __v_16); let __v_25: G = (__v_23 + __v_24); let __ret: [G; OUT_22] = [__v_22, __v_25]; record.function_queries[22].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_22(inp: [G; IN_22], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_2 * __v_2; let __v_5: G = G::from_u64(7); let __v_6: G = __v_3 * __v_3; let __v_7: G = __v_5 * __v_6; let __v_8: G = __v_4 - __v_7; let __v_9: G = aiur::execute::g_inverse_value(__v_8); let __v_10: G = __v_8 * __v_9; let __v_11: G = G::from_u64(1); let __v_12: G = __v_10 - __v_11; let __v_13: G = __v_8 * __v_12; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = __v_9 * __v_12; if (__v_15 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_16: G = __v_2 * __v_9; let __v_17: G = __v_14 - __v_3; let __v_18: G = __v_17 * __v_9; let __v_19: G = __v_0 * __v_16; let __v_20: G = __v_1 * __v_18; let __v_21: G = __v_5 * __v_20; let __v_22: G = __v_19 + __v_21; let __v_23: G = __v_0 * __v_18; let __v_24: G = __v_1 * __v_16; let __v_25: G = __v_23 + __v_24; let __ret: [G; OUT_22] = [__v_22, __v_25]; record.function_queries[22].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_23: usize = 4; const IN_23: usize = 4; const OUT_23: usize = 1; -fn aiur_fn_23(inp: [G; IN_23], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_1 - __v_3); let __v_7: G = G::from_bool((__v_6 == G::ZERO)); let __v_8: G = (__v_5 * __v_7); let __ret: [G; OUT_23] = [__v_8]; record.function_queries[23].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_23(inp: [G; IN_23], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = __v_0 - __v_2; let __v_5: G = G::from_bool(__v_4 == G::ZERO); let __v_6: G = __v_1 - __v_3; let __v_7: G = G::from_bool(__v_6 == G::ZERO); let __v_8: G = __v_5 * __v_7; let __ret: [G; OUT_23] = [__v_8]; record.function_queries[23].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_24: usize = 1; const IN_24: usize = 1; const OUT_24: usize = 2; -fn aiur_fn_24(inp: [G; IN_24], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_24] = [__v_2, __v_3]; record.function_queries[24].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_24] = [__v_4, __v_6]; record.function_queries[24].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_24(inp: [G; IN_24], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_24] = [__v_2, __v_3]; record.function_queries[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_24] = [__v_4, __v_6]; record.function_queries[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_25: usize = 1; const IN_25: usize = 1; const OUT_25: usize = 9; -fn aiur_fn_25(inp: [G; IN_25], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, (&__args[..]))?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { (*(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24])) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[25].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_25(inp: [G; IN_25], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(24, &__args[..])?) { [G::ZERO; OUT_24] } else { let (__hash, __hit) = record.function_queries[24].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[24].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => { aiur_fn_24::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[25].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_26: usize = 1; const IN_26: usize = 1; const OUT_26: usize = 2; -fn aiur_fn_26(inp: [G; IN_26], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, (&__args[..]))?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { (*(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25])) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10, __v_9]; record.function_queries[26].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_26(inp: [G; IN_26], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, &__args[..])?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10, __v_9]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_27: usize = 1; const IN_27: usize = 1; const OUT_27: usize = 2; -fn aiur_fn_27(inp: [G; IN_27], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_27] = [__v_2, __v_4]; record.function_queries[27].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_27(inp: [G; IN_27], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 + __v_3; let __ret: [G; OUT_27] = [__v_2, __v_4]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_28: usize = 1; const IN_28: usize = 1; const OUT_28: usize = 9; -fn aiur_fn_28(inp: [G; IN_28], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = __io_read[1]; let __v_4: G = __io_read[2]; let __v_5: G = __io_read[3]; let __v_6: G = __io_read[4]; let __v_7: G = __io_read[5]; let __v_8: G = __io_read[6]; let __v_9: G = __io_read[7]; let __v_10: G = G::from_u64(8); let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[28].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_28(inp: [G; IN_28], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = __io_read[1]; let __v_4: G = __io_read[2]; let __v_5: G = __io_read[3]; let __v_6: G = __io_read[4]; let __v_7: G = __io_read[5]; let __v_8: G = __io_read[6]; let __v_9: G = __io_read[7]; let __v_10: G = G::from_u64(8); let __v_11: G = __v_0 + __v_10; let __ret: [G; OUT_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; record.function_queries[28].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_29: usize = 1; const IN_29: usize = 1; const OUT_29: usize = 2; -fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, (&__args[..]))?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { (*(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12])) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10, __v_9]; record.function_queries[29].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_29(inp: [G; IN_29], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(12, &__args[..])?) { [G::ZERO; OUT_12] } else { let (__hash, __hit) = record.function_queries[12].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[12].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => { aiur_fn_12::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10, __v_9]; record.function_queries[29].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_30: usize = 1; const IN_30: usize = 1; const OUT_30: usize = 3; -fn aiur_fn_30(inp: [G; IN_30], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = G::from_u64(256); let __v_20: G = (__v_19 * __v_2); let __v_21: G = G::from_u64(65536); let __v_22: G = (__v_21 * __v_3); let __v_23: G = G::from_u64(16777216); let __v_24: G = (__v_23 * __v_4); let __v_25: G = G::from_u64(4294967296); let __v_26: G = (__v_25 * __v_5); let __v_27: G = G::from_u64(1099511627776); let __v_28: G = (__v_27 * __v_6); let __v_29: G = G::from_u64(281474976710656); let __v_30: G = (__v_29 * __v_7); let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = (__v_31 * __v_8); let __v_33: G = (__v_30 + __v_32); let __v_34: G = (__v_28 + __v_33); let __v_35: G = (__v_26 + __v_34); let __v_36: G = (__v_24 + __v_35); let __v_37: G = (__v_22 + __v_36); let __v_38: G = (__v_20 + __v_37); let __v_39: G = (__v_1 + __v_38); let __v_40: G = (__v_19 * __v_11); let __v_41: G = (__v_21 * __v_12); let __v_42: G = (__v_23 * __v_13); let __v_43: G = (__v_25 * __v_14); let __v_44: G = (__v_27 * __v_15); let __v_45: G = (__v_29 * __v_16); let __v_46: G = (__v_31 * __v_17); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_44 + __v_47); let __v_49: G = (__v_43 + __v_48); let __v_50: G = (__v_42 + __v_49); let __v_51: G = (__v_41 + __v_50); let __v_52: G = (__v_40 + __v_51); let __v_53: G = (__v_10 + __v_52); let __ret: [G; OUT_30] = [__v_39, __v_53, __v_18]; record.function_queries[30].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_30(inp: [G; IN_30], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = G::from_u64(256); let __v_20: G = __v_19 * __v_2; let __v_21: G = G::from_u64(65536); let __v_22: G = __v_21 * __v_3; let __v_23: G = G::from_u64(16777216); let __v_24: G = __v_23 * __v_4; let __v_25: G = G::from_u64(4294967296); let __v_26: G = __v_25 * __v_5; let __v_27: G = G::from_u64(1099511627776); let __v_28: G = __v_27 * __v_6; let __v_29: G = G::from_u64(281474976710656); let __v_30: G = __v_29 * __v_7; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_8; let __v_33: G = __v_30 + __v_32; let __v_34: G = __v_28 + __v_33; let __v_35: G = __v_26 + __v_34; let __v_36: G = __v_24 + __v_35; let __v_37: G = __v_22 + __v_36; let __v_38: G = __v_20 + __v_37; let __v_39: G = __v_1 + __v_38; let __v_40: G = __v_19 * __v_11; let __v_41: G = __v_21 * __v_12; let __v_42: G = __v_23 * __v_13; let __v_43: G = __v_25 * __v_14; let __v_44: G = __v_27 * __v_15; let __v_45: G = __v_29 * __v_16; let __v_46: G = __v_31 * __v_17; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_44 + __v_47; let __v_49: G = __v_43 + __v_48; let __v_50: G = __v_42 + __v_49; let __v_51: G = __v_41 + __v_50; let __v_52: G = __v_40 + __v_51; let __v_53: G = __v_10 + __v_52; let __ret: [G; OUT_30] = [__v_39, __v_53, __v_18]; record.function_queries[30].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_31: usize = 1; const IN_31: usize = 1; const OUT_31: usize = 33; -fn aiur_fn_31(inp: [G; IN_31], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[31].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_31(inp: [G; IN_31], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[31].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_32: usize = 1; const IN_32: usize = 1; const OUT_32: usize = 2; -fn aiur_fn_32(inp: [G; IN_32], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_32] = [__v_3, __v_4]; record.function_queries[32].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_32(inp: [G; IN_32], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_32] = [__v_3, __v_4]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_33: usize = 2; const IN_33: usize = 2; const OUT_33: usize = 2; -fn aiur_fn_33(inp: [G; IN_33], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_3, __v_0]; record.function_queries[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_9, __v_7]; record.function_queries[33].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_33(inp: [G; IN_33], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_3, __v_0]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_33] = [__v_9, __v_7]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_34: usize = 1; const IN_34: usize = 1; const OUT_34: usize = 2; -fn aiur_fn_34(inp: [G; IN_34], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_34(inp: [G; IN_34], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_34] = [__v_3, __v_4]; record.function_queries[34].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_35: usize = 2; const IN_35: usize = 2; const OUT_35: usize = 2; -fn aiur_fn_35(inp: [G; IN_35], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_3, __v_0]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, (&__args[..]))?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { (*(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35])) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_16, __v_14]; record.function_queries[35].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_35(inp: [G; IN_35], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_3, __v_0]; record.function_queries[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(35, &__args[..])?) { [G::ZERO; OUT_35] } else { let (__hash, __hit) = record.function_queries[35].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[35].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => { aiur_fn_35::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_35] = [__v_16, __v_14]; record.function_queries[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_36: usize = 1; const IN_36: usize = 1; const OUT_36: usize = 2; -fn aiur_fn_36(inp: [G; IN_36], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, (&__args[..]))?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { (*(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37])) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_36(inp: [G; IN_36], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, &__args[..])?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_36] = [__v_3, __v_4]; record.function_queries[36].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_37: usize = 2; const IN_37: usize = 2; const OUT_37: usize = 2; -fn aiur_fn_37(inp: [G; IN_37], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = G::from_u64(256); let __v_21: G = (__v_20 * __v_3); let __v_22: G = G::from_u64(65536); let __v_23: G = (__v_22 * __v_4); let __v_24: G = G::from_u64(16777216); let __v_25: G = (__v_24 * __v_5); let __v_26: G = G::from_u64(4294967296); let __v_27: G = (__v_26 * __v_6); let __v_28: G = G::from_u64(1099511627776); let __v_29: G = (__v_28 * __v_7); let __v_30: G = G::from_u64(281474976710656); let __v_31: G = (__v_30 * __v_8); let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = (__v_32 * __v_9); let __v_34: G = (__v_31 + __v_33); let __v_35: G = (__v_29 + __v_34); let __v_36: G = (__v_27 + __v_35); let __v_37: G = (__v_25 + __v_36); let __v_38: G = (__v_23 + __v_37); let __v_39: G = (__v_21 + __v_38); let __v_40: G = (__v_2 + __v_39); let __v_41: G = (__v_20 * __v_12); let __v_42: G = (__v_22 * __v_13); let __v_43: G = (__v_24 * __v_14); let __v_44: G = (__v_26 * __v_15); let __v_45: G = (__v_28 * __v_16); let __v_46: G = (__v_30 * __v_17); let __v_47: G = (__v_32 * __v_18); let __v_48: G = (__v_46 + __v_47); let __v_49: G = (__v_45 + __v_48); let __v_50: G = (__v_44 + __v_49); let __v_51: G = (__v_43 + __v_50); let __v_52: G = (__v_42 + __v_51); let __v_53: G = (__v_41 + __v_52); let __v_54: G = (__v_11 + __v_53); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_1 - __v_55); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, (&__args[..]))?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { (*(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37])) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_59, __v_40, __v_54, __v_57]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_60, __v_58]; record.function_queries[37].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_37(inp: [G; IN_37], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = G::from_u64(256); let __v_21: G = __v_20 * __v_3; let __v_22: G = G::from_u64(65536); let __v_23: G = __v_22 * __v_4; let __v_24: G = G::from_u64(16777216); let __v_25: G = __v_24 * __v_5; let __v_26: G = G::from_u64(4294967296); let __v_27: G = __v_26 * __v_6; let __v_28: G = G::from_u64(1099511627776); let __v_29: G = __v_28 * __v_7; let __v_30: G = G::from_u64(281474976710656); let __v_31: G = __v_30 * __v_8; let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = __v_32 * __v_9; let __v_34: G = __v_31 + __v_33; let __v_35: G = __v_29 + __v_34; let __v_36: G = __v_27 + __v_35; let __v_37: G = __v_25 + __v_36; let __v_38: G = __v_23 + __v_37; let __v_39: G = __v_21 + __v_38; let __v_40: G = __v_2 + __v_39; let __v_41: G = __v_20 * __v_12; let __v_42: G = __v_22 * __v_13; let __v_43: G = __v_24 * __v_14; let __v_44: G = __v_26 * __v_15; let __v_45: G = __v_28 * __v_16; let __v_46: G = __v_30 * __v_17; let __v_47: G = __v_32 * __v_18; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_45 + __v_48; let __v_50: G = __v_44 + __v_49; let __v_51: G = __v_43 + __v_50; let __v_52: G = __v_42 + __v_51; let __v_53: G = __v_41 + __v_52; let __v_54: G = __v_11 + __v_53; let __v_55: G = G::from_u64(1); let __v_56: G = __v_1 - __v_55; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(37, &__args[..])?) { [G::ZERO; OUT_37] } else { let (__hash, __hit) = record.function_queries[37].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[37].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => { aiur_fn_37::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_59, __v_40, __v_54, __v_57]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_37] = [__v_60, __v_58]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_38: usize = 1; const IN_38: usize = 1; const OUT_38: usize = 2; -fn aiur_fn_38(inp: [G; IN_38], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, (&__args[..]))?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { (*(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39])) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_38(inp: [G; IN_38], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, &__args[..])?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_38] = [__v_3, __v_4]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_39: usize = 2; const IN_39: usize = 2; const OUT_39: usize = 2; -fn aiur_fn_39(inp: [G; IN_39], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, (&__args[..]))?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { (*(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39])) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_44, __v_41]; record.function_queries[39].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_39(inp: [G; IN_39], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(39, &__args[..])?) { [G::ZERO; OUT_39] } else { let (__hash, __hit) = record.function_queries[39].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[39].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => { aiur_fn_39::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_39] = [__v_44, __v_41]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_40: usize = 1; const IN_40: usize = 1; const OUT_40: usize = 2; -fn aiur_fn_40(inp: [G; IN_40], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_40(inp: [G; IN_40], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_40] = [__v_3, __v_4]; record.function_queries[40].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_41: usize = 2; const IN_41: usize = 2; const OUT_41: usize = 2; -fn aiur_fn_41(inp: [G; IN_41], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_3, __v_0]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_9, __v_7]; record.function_queries[41].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_41(inp: [G; IN_41], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_3, __v_0]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_41] = [__v_9, __v_7]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_42: usize = 1; const IN_42: usize = 1; const OUT_42: usize = 2; -fn aiur_fn_42(inp: [G; IN_42], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_42(inp: [G; IN_42], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_42] = [__v_3, __v_4]; record.function_queries[42].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_43: usize = 2; const IN_43: usize = 2; const OUT_43: usize = 2; -fn aiur_fn_43(inp: [G; IN_43], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_3, __v_0]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_11, __v_9]; record.function_queries[43].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_43(inp: [G; IN_43], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_3, __v_0]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_43] = [__v_11, __v_9]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_44: usize = 1; const IN_44: usize = 1; const OUT_44: usize = 2; -fn aiur_fn_44(inp: [G; IN_44], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_44(inp: [G; IN_44], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_3, __v_4]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_45: usize = 2; const IN_45: usize = 2; const OUT_45: usize = 2; -fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_3, __v_0]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_9, __v_7]; record.function_queries[45].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_45(inp: [G; IN_45], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_3, __v_0]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_45] = [__v_9, __v_7]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_46: usize = 1; const IN_46: usize = 1; const OUT_46: usize = 2; -fn aiur_fn_46(inp: [G; IN_46], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_3, __v_4]; record.function_queries[46].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_46(inp: [G; IN_46], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_46] = [__v_3, __v_4]; record.function_queries[46].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_47: usize = 2; const IN_47: usize = 2; const OUT_47: usize = 2; -fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_3, __v_0]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(44, (&__args[..]))?) { [G::ZERO; OUT_44] } else { let (__hash, __hit) = record.function_queries[44].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[44].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { (*(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44])) }; __ret }, _ => { aiur_fn_44::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, (&__args[..]))?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { (*(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47])) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_9, __v_7]; record.function_queries[47].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_47(inp: [G; IN_47], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_3, __v_0]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(44, &__args[..])?) { [G::ZERO; OUT_44] } else { let (__hash, __hit) = record.function_queries[44].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[44].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => { aiur_fn_44::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(47, &__args[..])?) { [G::ZERO; OUT_47] } else { let (__hash, __hit) = record.function_queries[47].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[47].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => { aiur_fn_47::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_47] = [__v_9, __v_7]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_48: usize = 1; const IN_48: usize = 1; const OUT_48: usize = 2; -fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_1, __v_2]; record.function_queries[48].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_48(inp: [G; IN_48], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_1, __v_2]; record.function_queries[48].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_49: usize = 1; const IN_49: usize = 1; const OUT_49: usize = 2; -fn aiur_fn_49(inp: [G; IN_49], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_3, __v_4]; record.function_queries[49].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_49(inp: [G; IN_49], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_3, __v_4]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_50: usize = 2; const IN_50: usize = 2; const OUT_50: usize = 2; -fn aiur_fn_50(inp: [G; IN_50], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_3, __v_0]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_9, __v_7]; record.function_queries[50].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_50(inp: [G; IN_50], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_3, __v_0]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_50] = [__v_9, __v_7]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_51: usize = 1; const IN_51: usize = 1; const OUT_51: usize = 4; -fn aiur_fn_51(inp: [G; IN_51], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[51].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_51(inp: [G; IN_51], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[51].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_52: usize = 1; const IN_52: usize = 1; const OUT_52: usize = 3; -fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_52] = [__v_3, __v_5, __v_6]; record.function_queries[52].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_52(inp: [G; IN_52], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_52] = [__v_3, __v_5, __v_6]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_53: usize = 1; const IN_53: usize = 1; const OUT_53: usize = 2; -fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_3, __v_4]; record.function_queries[53].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_53(inp: [G; IN_53], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_3, __v_4]; record.function_queries[53].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_54: usize = 2; const IN_54: usize = 2; const OUT_54: usize = 2; -fn aiur_fn_54(inp: [G; IN_54], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_3, __v_0]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, (&__args[..]))?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { (*(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43])) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_13, __v_11]; record.function_queries[54].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_54(inp: [G; IN_54], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_3, __v_0]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(43, &__args[..])?) { [G::ZERO; OUT_43] } else { let (__hash, __hit) = record.function_queries[43].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[43].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => { aiur_fn_43::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_54] = [__v_13, __v_11]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_55: usize = 1; const IN_55: usize = 1; const OUT_55: usize = 4; -fn aiur_fn_55(inp: [G; IN_55], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_1, __v_5, __v_7, __v_8]; record.function_queries[55].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_55(inp: [G; IN_55], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_1, __v_5, __v_7, __v_8]; record.function_queries[55].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_56: usize = 1; const IN_56: usize = 1; const OUT_56: usize = 2; -fn aiur_fn_56(inp: [G; IN_56], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_3, __v_4]; record.function_queries[56].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_56(inp: [G; IN_56], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_3, __v_4]; record.function_queries[56].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_57: usize = 2; const IN_57: usize = 2; const OUT_57: usize = 2; -fn aiur_fn_57(inp: [G; IN_57], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 5] = [__v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 5)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_3, __v_0]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, (&__args[..]))?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { (*(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45])) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 5)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_15, __v_13]; record.function_queries[57].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_57(inp: [G; IN_57], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 5] = [__v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 5)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_3, __v_0]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(45, &__args[..])?) { [G::ZERO; OUT_45] } else { let (__hash, __hit) = record.function_queries[45].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[45].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => { aiur_fn_45::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = __v_1 - __v_10; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 5)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_57] = [__v_15, __v_13]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_58: usize = 1; const IN_58: usize = 1; const OUT_58: usize = 14; -fn aiur_fn_58(inp: [G; IN_58], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __ret: [G; OUT_58] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[58].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_58(inp: [G; IN_58], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __ret: [G; OUT_58] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[58].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_59: usize = 1; const IN_59: usize = 1; const OUT_59: usize = 3; -fn aiur_fn_59(inp: [G; IN_59], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { (*(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27])) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_59] = [__v_3, __v_3, __v_2]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_59] = [__v_5, __v_3, __v_4]; record.function_queries[59].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_59(inp: [G; IN_59], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => { aiur_fn_27::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_59] = [__v_3, __v_3, __v_2]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_59] = [__v_5, __v_3, __v_4]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_60: usize = 1; const IN_60: usize = 1; const OUT_60: usize = 25; -fn aiur_fn_60(inp: [G; IN_60], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, (&__args[..]))?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { (*(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50])) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, (&__args[..]))?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { (*(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54])) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_28, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, (&__args[..]))?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { (*(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57])) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, (&__args[..]))?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { (*(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36])) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; let __v_36: G = __r_arr[3]; let __v_37: G = __r_arr[4]; let __v_38: G = __r_arr[5]; let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, (&__args[..]))?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { (*(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59])) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, (&__args[..]))?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { (*(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46])) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_60] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; record.function_queries[60].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_60(inp: [G; IN_60], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_14, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(50, &__args[..])?) { [G::ZERO; OUT_50] } else { let (__hash, __hit) = record.function_queries[50].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[50].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => { aiur_fn_50::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(54, &__args[..])?) { [G::ZERO; OUT_54] } else { let (__hash, __hit) = record.function_queries[54].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[54].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => { aiur_fn_54::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_28, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(57, &__args[..])?) { [G::ZERO; OUT_57] } else { let (__hash, __hit) = record.function_queries[57].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[57].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => { aiur_fn_57::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(36, &__args[..])?) { [G::ZERO; OUT_36] } else { let (__hash, __hit) = record.function_queries[36].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[36].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => { aiur_fn_36::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; let __v_36: G = __r_arr[3]; let __v_37: G = __r_arr[4]; let __v_38: G = __r_arr[5]; let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(59, &__args[..])?) { [G::ZERO; OUT_59] } else { let (__hash, __hit) = record.function_queries[59].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[59].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => { aiur_fn_59::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(46, &__args[..])?) { [G::ZERO; OUT_46] } else { let (__hash, __hit) = record.function_queries[46].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[46].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => { aiur_fn_46::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_60] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_61: usize = 1; const IN_61: usize = 1; const OUT_61: usize = 5; -fn aiur_fn_61(inp: [G; IN_61], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_3, __v_5, __v_9, __v_13, __v_14]; record.function_queries[61].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_61(inp: [G; IN_61], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_3, __v_5, __v_9, __v_13, __v_14]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_62: usize = 1; const IN_62: usize = 1; const OUT_62: usize = 2; -fn aiur_fn_62(inp: [G; IN_62], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_62] = [__v_3, __v_4]; record.function_queries[62].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_62(inp: [G; IN_62], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_62] = [__v_3, __v_4]; record.function_queries[62].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_63: usize = 2; const IN_63: usize = 2; const OUT_63: usize = 2; -fn aiur_fn_63(inp: [G; IN_63], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_3, __v_0]; record.function_queries[63].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, (&__args[..]))?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { (*(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38])) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_9, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, (&__args[..]))?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { (*(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33])) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, (&__args[..]))?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { (*(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41])) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_1 - __v_16); let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 6] = [__v_20, __v_4, __v_6, __v_10, __v_14, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_21, __v_19]; record.function_queries[63].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_63(inp: [G; IN_63], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 6] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_3, __v_0]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(38, &__args[..])?) { [G::ZERO; OUT_38] } else { let (__hash, __hit) = record.function_queries[38].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[38].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => { aiur_fn_38::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_9, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(33, &__args[..])?) { [G::ZERO; OUT_33] } else { let (__hash, __hit) = record.function_queries[33].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[33].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => { aiur_fn_33::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(41, &__args[..])?) { [G::ZERO; OUT_41] } else { let (__hash, __hit) = record.function_queries[41].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[41].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => { aiur_fn_41::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(1); let __v_17: G = __v_1 - __v_16; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 6] = [__v_20, __v_4, __v_6, __v_10, __v_14, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_63] = [__v_21, __v_19]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_64: usize = 1; const IN_64: usize = 1; const OUT_64: usize = 10; -fn aiur_fn_64(inp: [G; IN_64], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __ret: [G; OUT_64] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[64].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_64(inp: [G; IN_64], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __ret: [G; OUT_64] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_65: usize = 1; const IN_65: usize = 1; const OUT_65: usize = 2; -fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_65] = [__v_3, __v_4]; record.function_queries[65].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_65(inp: [G; IN_65], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_65] = [__v_3, __v_4]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_66: usize = 2; const IN_66: usize = 2; const OUT_66: usize = 2; -fn aiur_fn_66(inp: [G; IN_66], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_3, __v_0]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, (&__args[..]))?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { (*(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34])) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { (*(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28])) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 11] = [__v_17, __v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_15]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_18, __v_16]; record.function_queries[66].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_66(inp: [G; IN_66], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_3, __v_0]; record.function_queries[66].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(34, &__args[..])?) { [G::ZERO; OUT_34] } else { let (__hash, __hit) = record.function_queries[34].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[34].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => { aiur_fn_34::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => { aiur_fn_28::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = G::from_u64(1); let __v_14: G = __v_1 - __v_13; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 11] = [__v_17, __v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_15]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_66] = [__v_18, __v_16]; record.function_queries[66].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_67: usize = 1; const IN_67: usize = 1; const OUT_67: usize = 2; -fn aiur_fn_67(inp: [G; IN_67], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_67] = [__v_3, __v_4]; record.function_queries[67].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_67(inp: [G; IN_67], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_67] = [__v_3, __v_4]; record.function_queries[67].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_68: usize = 2; const IN_68: usize = 2; const OUT_68: usize = 2; -fn aiur_fn_68(inp: [G; IN_68], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 26] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 26)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_3, __v_0]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(60, (&__args[..]))?) { [G::ZERO; OUT_60] } else { let (__hash, __hit) = record.function_queries[60].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[60].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { (*(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60])) }; __ret }, _ => { aiur_fn_60::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = G::from_u64(1); let __v_28: G = (__v_1 - __v_27); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 26] = [__v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 26)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_32, __v_30]; record.function_queries[68].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_68(inp: [G; IN_68], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 26] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 26)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_3, __v_0]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(60, &__args[..])?) { [G::ZERO; OUT_60] } else { let (__hash, __hit) = record.function_queries[60].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[60].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => { aiur_fn_60::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = G::from_u64(1); let __v_28: G = __v_1 - __v_27; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 26] = [__v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 26)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_68] = [__v_32, __v_30]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_69: usize = 1; const IN_69: usize = 1; const OUT_69: usize = 4; -fn aiur_fn_69(inp: [G; IN_69], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[69].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_69(inp: [G; IN_69], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[69].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_70: usize = 4; const IN_70: usize = 4; const OUT_70: usize = 1; -fn aiur_fn_70(inp: [G; IN_70], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); let __v_7: G = (__v_6 * __v_2); let __v_8: G = G::from_u64(16777216); let __v_9: G = (__v_8 * __v_3); let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_70] = [__v_12]; record.function_queries[70].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_70(inp: [G; IN_70], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(256); let __v_5: G = __v_4 * __v_1; let __v_6: G = G::from_u64(65536); let __v_7: G = __v_6 * __v_2; let __v_8: G = G::from_u64(16777216); let __v_9: G = __v_8 * __v_3; let __v_10: G = __v_7 + __v_9; let __v_11: G = __v_5 + __v_10; let __v_12: G = __v_0 + __v_11; let __ret: [G; OUT_70] = [__v_12]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_71: usize = 32; const IN_71: usize = 32; const OUT_71: usize = 8; -fn aiur_fn_71(inp: [G; IN_71], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = G::from_u64(65536); let __v_35: G = (__v_34 * __v_2); let __v_36: G = G::from_u64(16777216); let __v_37: G = (__v_36 * __v_3); let __v_38: G = (__v_35 + __v_37); let __v_39: G = (__v_33 + __v_38); let __v_40: G = (__v_0 + __v_39); let __v_41: G = (__v_32 * __v_5); let __v_42: G = (__v_34 * __v_6); let __v_43: G = (__v_36 * __v_7); let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_41 + __v_44); let __v_46: G = (__v_4 + __v_45); let __v_47: G = (__v_32 * __v_9); let __v_48: G = (__v_34 * __v_10); let __v_49: G = (__v_36 * __v_11); let __v_50: G = (__v_48 + __v_49); let __v_51: G = (__v_47 + __v_50); let __v_52: G = (__v_8 + __v_51); let __v_53: G = (__v_32 * __v_13); let __v_54: G = (__v_34 * __v_14); let __v_55: G = (__v_36 * __v_15); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_12 + __v_57); let __v_59: G = (__v_32 * __v_17); let __v_60: G = (__v_34 * __v_18); let __v_61: G = (__v_36 * __v_19); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_16 + __v_63); let __v_65: G = (__v_32 * __v_21); let __v_66: G = (__v_34 * __v_22); let __v_67: G = (__v_36 * __v_23); let __v_68: G = (__v_66 + __v_67); let __v_69: G = (__v_65 + __v_68); let __v_70: G = (__v_20 + __v_69); let __v_71: G = (__v_32 * __v_25); let __v_72: G = (__v_34 * __v_26); let __v_73: G = (__v_36 * __v_27); let __v_74: G = (__v_72 + __v_73); let __v_75: G = (__v_71 + __v_74); let __v_76: G = (__v_24 + __v_75); let __v_77: G = (__v_32 * __v_29); let __v_78: G = (__v_34 * __v_30); let __v_79: G = (__v_36 * __v_31); let __v_80: G = (__v_78 + __v_79); let __v_81: G = (__v_77 + __v_80); let __v_82: G = (__v_28 + __v_81); let __ret: [G; OUT_71] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[71].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_71(inp: [G; IN_71], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = G::from_u64(256); let __v_33: G = __v_32 * __v_1; let __v_34: G = G::from_u64(65536); let __v_35: G = __v_34 * __v_2; let __v_36: G = G::from_u64(16777216); let __v_37: G = __v_36 * __v_3; let __v_38: G = __v_35 + __v_37; let __v_39: G = __v_33 + __v_38; let __v_40: G = __v_0 + __v_39; let __v_41: G = __v_32 * __v_5; let __v_42: G = __v_34 * __v_6; let __v_43: G = __v_36 * __v_7; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_41 + __v_44; let __v_46: G = __v_4 + __v_45; let __v_47: G = __v_32 * __v_9; let __v_48: G = __v_34 * __v_10; let __v_49: G = __v_36 * __v_11; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_47 + __v_50; let __v_52: G = __v_8 + __v_51; let __v_53: G = __v_32 * __v_13; let __v_54: G = __v_34 * __v_14; let __v_55: G = __v_36 * __v_15; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_53 + __v_56; let __v_58: G = __v_12 + __v_57; let __v_59: G = __v_32 * __v_17; let __v_60: G = __v_34 * __v_18; let __v_61: G = __v_36 * __v_19; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_59 + __v_62; let __v_64: G = __v_16 + __v_63; let __v_65: G = __v_32 * __v_21; let __v_66: G = __v_34 * __v_22; let __v_67: G = __v_36 * __v_23; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_65 + __v_68; let __v_70: G = __v_20 + __v_69; let __v_71: G = __v_32 * __v_25; let __v_72: G = __v_34 * __v_26; let __v_73: G = __v_36 * __v_27; let __v_74: G = __v_72 + __v_73; let __v_75: G = __v_71 + __v_74; let __v_76: G = __v_24 + __v_75; let __v_77: G = __v_32 * __v_29; let __v_78: G = __v_34 * __v_30; let __v_79: G = __v_36 * __v_31; let __v_80: G = __v_78 + __v_79; let __v_81: G = __v_77 + __v_80; let __v_82: G = __v_28 + __v_81; let __ret: [G; OUT_71] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[71].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_72: usize = 1; const IN_72: usize = 1; const OUT_72: usize = 32; -fn aiur_fn_72(inp: [G; IN_72], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_72] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[72].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_72(inp: [G; IN_72], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_72] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[72].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_73: usize = 34; const IN_73: usize = 34; const OUT_73: usize = 34; -fn aiur_fn_73(inp: [G; IN_73], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __loaded[32]; let __v_67: G = __loaded[33]; match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_73] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(73, (&__args[..]))?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { (*(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73])) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; let __v_72: G = __r_arr[3]; let __v_73: G = __r_arr[4]; let __v_74: G = __r_arr[5]; let __v_75: G = __r_arr[6]; let __v_76: G = __r_arr[7]; let __v_77: G = __r_arr[8]; let __v_78: G = __r_arr[9]; let __v_79: G = __r_arr[10]; let __v_80: G = __r_arr[11]; let __v_81: G = __r_arr[12]; let __v_82: G = __r_arr[13]; let __v_83: G = __r_arr[14]; let __v_84: G = __r_arr[15]; let __v_85: G = __r_arr[16]; let __v_86: G = __r_arr[17]; let __v_87: G = __r_arr[18]; let __v_88: G = __r_arr[19]; let __v_89: G = __r_arr[20]; let __v_90: G = __r_arr[21]; let __v_91: G = __r_arr[22]; let __v_92: G = __r_arr[23]; let __v_93: G = __r_arr[24]; let __v_94: G = __r_arr[25]; let __v_95: G = __r_arr[26]; let __v_96: G = __r_arr[27]; let __v_97: G = __r_arr[28]; let __v_98: G = __r_arr[29]; let __v_99: G = __r_arr[30]; let __v_100: G = __r_arr[31]; let __v_101: G = __r_arr[32]; let __v_102: G = __r_arr[33]; match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_73] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_103: G = G::from_u64(4); let __v_104: G = G::from_u64(8); let __v_105: G = G::from_u64(103); let __v_106: G = G::from_u64(230); let __v_107: G = G::from_u64(9); let __v_108: G = G::from_u64(106); let __v_109: G = G::from_u64(133); let __v_110: G = G::from_u64(174); let __v_111: G = G::from_u64(187); let __v_112: G = G::from_u64(114); let __v_113: G = G::from_u64(243); let __v_114: G = G::from_u64(110); let __v_115: G = G::from_u64(60); let __v_116: G = G::from_u64(58); let __v_117: G = G::from_u64(245); let __v_118: G = G::from_u64(79); let __v_119: G = G::from_u64(165); let __v_120: G = G::from_u64(127); let __v_121: G = G::from_u64(82); let __v_122: G = G::from_u64(14); let __v_123: G = G::from_u64(81); let __v_124: G = G::from_u64(140); let __v_125: G = G::from_u64(104); let __v_126: G = G::from_u64(5); let __v_127: G = G::from_u64(155); let __v_128: G = G::from_u64(171); let __v_129: G = G::from_u64(217); let __v_130: G = G::from_u64(131); let __v_131: G = G::from_u64(31); let __v_132: G = G::from_u64(25); let __v_133: G = G::from_u64(205); let __v_134: G = G::from_u64(224); let __v_135: G = G::from_u64(91); let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; let __v_139: G = __loaded[3]; let __v_140: G = __loaded[4]; let __v_141: G = __loaded[5]; let __v_142: G = __loaded[6]; let __v_143: G = __loaded[7]; let __v_144: G = __loaded[8]; let __v_145: G = __loaded[9]; let __v_146: G = __loaded[10]; let __v_147: G = __loaded[11]; let __v_148: G = __loaded[12]; let __v_149: G = __loaded[13]; let __v_150: G = __loaded[14]; let __v_151: G = __loaded[15]; let __v_152: G = __loaded[16]; let __v_153: G = __loaded[17]; let __v_154: G = __loaded[18]; let __v_155: G = __loaded[19]; let __v_156: G = __loaded[20]; let __v_157: G = __loaded[21]; let __v_158: G = __loaded[22]; let __v_159: G = __loaded[23]; let __v_160: G = __loaded[24]; let __v_161: G = __loaded[25]; let __v_162: G = __loaded[26]; let __v_163: G = __loaded[27]; let __v_164: G = __loaded[28]; let __v_165: G = __loaded[29]; let __v_166: G = __loaded[30]; let __v_167: G = __loaded[31]; let __v_168: G = __loaded[32]; let __v_169: G = __loaded[33]; match __v_136.as_canonical_u64() { 1u64 => { let __v_170: G = (__v_104 * __v_33); let __v_171: G = (__v_103 + __v_170); let __v_172: G = G::from_u64(0); let __v_173: G = G::from_u64(64); let __v_174: G = G::from_u64(103); let __v_175: G = G::from_u64(230); let __v_176: G = G::from_u64(9); let __v_177: G = G::from_u64(106); let __v_178: G = G::from_u64(133); let __v_179: G = G::from_u64(174); let __v_180: G = G::from_u64(187); let __v_181: G = G::from_u64(114); let __v_182: G = G::from_u64(243); let __v_183: G = G::from_u64(110); let __v_184: G = G::from_u64(60); let __v_185: G = G::from_u64(58); let __v_186: G = G::from_u64(245); let __v_187: G = G::from_u64(79); let __v_188: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_172, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_174, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_173, __v_172, __v_172, __v_172, __v_171, __v_172, __v_172, __v_172, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; let __v_192: G = __r_arr[3]; let __v_193: G = __r_arr[4]; let __v_194: G = __r_arr[5]; let __v_195: G = __r_arr[6]; let __v_196: G = __r_arr[7]; let __v_197: G = __r_arr[8]; let __v_198: G = __r_arr[9]; let __v_199: G = __r_arr[10]; let __v_200: G = __r_arr[11]; let __v_201: G = __r_arr[12]; let __v_202: G = __r_arr[13]; let __v_203: G = __r_arr[14]; let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; let __v_207: G = __r_arr[18]; let __v_208: G = __r_arr[19]; let __v_209: G = __r_arr[20]; let __v_210: G = __r_arr[21]; let __v_211: G = __r_arr[22]; let __v_212: G = __r_arr[23]; let __v_213: G = __r_arr[24]; let __v_214: G = __r_arr[25]; let __v_215: G = __r_arr[26]; let __v_216: G = __r_arr[27]; let __v_217: G = __r_arr[28]; let __v_218: G = __r_arr[29]; let __v_219: G = __r_arr[30]; let __v_220: G = __r_arr[31]; let __v_221: G = { let __values: [G; 34] = [__v_172, __v_102, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_221]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(64); let __v_172: G = G::from_u64(103); let __v_173: G = G::from_u64(230); let __v_174: G = G::from_u64(9); let __v_175: G = G::from_u64(106); let __v_176: G = G::from_u64(133); let __v_177: G = G::from_u64(174); let __v_178: G = G::from_u64(187); let __v_179: G = G::from_u64(114); let __v_180: G = G::from_u64(243); let __v_181: G = G::from_u64(110); let __v_182: G = G::from_u64(60); let __v_183: G = G::from_u64(58); let __v_184: G = G::from_u64(245); let __v_185: G = G::from_u64(79); let __v_186: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_170, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_172, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_171, __v_170, __v_170, __v_170, __v_103, __v_170, __v_170, __v_170, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; let __v_190: G = __r_arr[3]; let __v_191: G = __r_arr[4]; let __v_192: G = __r_arr[5]; let __v_193: G = __r_arr[6]; let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; let __v_197: G = __r_arr[10]; let __v_198: G = __r_arr[11]; let __v_199: G = __r_arr[12]; let __v_200: G = __r_arr[13]; let __v_201: G = __r_arr[14]; let __v_202: G = __r_arr[15]; let __v_203: G = __r_arr[16]; let __v_204: G = __r_arr[17]; let __v_205: G = __r_arr[18]; let __v_206: G = __r_arr[19]; let __v_207: G = __r_arr[20]; let __v_208: G = __r_arr[21]; let __v_209: G = __r_arr[22]; let __v_210: G = __r_arr[23]; let __v_211: G = __r_arr[24]; let __v_212: G = __r_arr[25]; let __v_213: G = __r_arr[26]; let __v_214: G = __r_arr[27]; let __v_215: G = __r_arr[28]; let __v_216: G = __r_arr[29]; let __v_217: G = __r_arr[30]; let __v_218: G = __r_arr[31]; let __v_219: G = { let __values: [G; 34] = [__v_170, __v_102, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_219]; record.function_queries[73].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } +fn aiur_fn_73(inp: [G; IN_73], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __loaded[32]; let __v_67: G = __loaded[33]; match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_73] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(73, &__args[..])?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; let __v_72: G = __r_arr[3]; let __v_73: G = __r_arr[4]; let __v_74: G = __r_arr[5]; let __v_75: G = __r_arr[6]; let __v_76: G = __r_arr[7]; let __v_77: G = __r_arr[8]; let __v_78: G = __r_arr[9]; let __v_79: G = __r_arr[10]; let __v_80: G = __r_arr[11]; let __v_81: G = __r_arr[12]; let __v_82: G = __r_arr[13]; let __v_83: G = __r_arr[14]; let __v_84: G = __r_arr[15]; let __v_85: G = __r_arr[16]; let __v_86: G = __r_arr[17]; let __v_87: G = __r_arr[18]; let __v_88: G = __r_arr[19]; let __v_89: G = __r_arr[20]; let __v_90: G = __r_arr[21]; let __v_91: G = __r_arr[22]; let __v_92: G = __r_arr[23]; let __v_93: G = __r_arr[24]; let __v_94: G = __r_arr[25]; let __v_95: G = __r_arr[26]; let __v_96: G = __r_arr[27]; let __v_97: G = __r_arr[28]; let __v_98: G = __r_arr[29]; let __v_99: G = __r_arr[30]; let __v_100: G = __r_arr[31]; let __v_101: G = __r_arr[32]; let __v_102: G = __r_arr[33]; match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_73] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_103: G = G::from_u64(4); let __v_104: G = G::from_u64(8); let __v_105: G = G::from_u64(103); let __v_106: G = G::from_u64(230); let __v_107: G = G::from_u64(9); let __v_108: G = G::from_u64(106); let __v_109: G = G::from_u64(133); let __v_110: G = G::from_u64(174); let __v_111: G = G::from_u64(187); let __v_112: G = G::from_u64(114); let __v_113: G = G::from_u64(243); let __v_114: G = G::from_u64(110); let __v_115: G = G::from_u64(60); let __v_116: G = G::from_u64(58); let __v_117: G = G::from_u64(245); let __v_118: G = G::from_u64(79); let __v_119: G = G::from_u64(165); let __v_120: G = G::from_u64(127); let __v_121: G = G::from_u64(82); let __v_122: G = G::from_u64(14); let __v_123: G = G::from_u64(81); let __v_124: G = G::from_u64(140); let __v_125: G = G::from_u64(104); let __v_126: G = G::from_u64(5); let __v_127: G = G::from_u64(155); let __v_128: G = G::from_u64(171); let __v_129: G = G::from_u64(217); let __v_130: G = G::from_u64(131); let __v_131: G = G::from_u64(31); let __v_132: G = G::from_u64(25); let __v_133: G = G::from_u64(205); let __v_134: G = G::from_u64(224); let __v_135: G = G::from_u64(91); let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; let __v_139: G = __loaded[3]; let __v_140: G = __loaded[4]; let __v_141: G = __loaded[5]; let __v_142: G = __loaded[6]; let __v_143: G = __loaded[7]; let __v_144: G = __loaded[8]; let __v_145: G = __loaded[9]; let __v_146: G = __loaded[10]; let __v_147: G = __loaded[11]; let __v_148: G = __loaded[12]; let __v_149: G = __loaded[13]; let __v_150: G = __loaded[14]; let __v_151: G = __loaded[15]; let __v_152: G = __loaded[16]; let __v_153: G = __loaded[17]; let __v_154: G = __loaded[18]; let __v_155: G = __loaded[19]; let __v_156: G = __loaded[20]; let __v_157: G = __loaded[21]; let __v_158: G = __loaded[22]; let __v_159: G = __loaded[23]; let __v_160: G = __loaded[24]; let __v_161: G = __loaded[25]; let __v_162: G = __loaded[26]; let __v_163: G = __loaded[27]; let __v_164: G = __loaded[28]; let __v_165: G = __loaded[29]; let __v_166: G = __loaded[30]; let __v_167: G = __loaded[31]; let __v_168: G = __loaded[32]; let __v_169: G = __loaded[33]; match __v_136.as_canonical_u64() { 1u64 => { let __v_170: G = __v_104 * __v_33; let __v_171: G = __v_103 + __v_170; let __v_172: G = G::from_u64(0); let __v_173: G = G::from_u64(64); let __v_174: G = G::from_u64(103); let __v_175: G = G::from_u64(230); let __v_176: G = G::from_u64(9); let __v_177: G = G::from_u64(106); let __v_178: G = G::from_u64(133); let __v_179: G = G::from_u64(174); let __v_180: G = G::from_u64(187); let __v_181: G = G::from_u64(114); let __v_182: G = G::from_u64(243); let __v_183: G = G::from_u64(110); let __v_184: G = G::from_u64(60); let __v_185: G = G::from_u64(58); let __v_186: G = G::from_u64(245); let __v_187: G = G::from_u64(79); let __v_188: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_172, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_174, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_173, __v_172, __v_172, __v_172, __v_171, __v_172, __v_172, __v_172, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; let __v_192: G = __r_arr[3]; let __v_193: G = __r_arr[4]; let __v_194: G = __r_arr[5]; let __v_195: G = __r_arr[6]; let __v_196: G = __r_arr[7]; let __v_197: G = __r_arr[8]; let __v_198: G = __r_arr[9]; let __v_199: G = __r_arr[10]; let __v_200: G = __r_arr[11]; let __v_201: G = __r_arr[12]; let __v_202: G = __r_arr[13]; let __v_203: G = __r_arr[14]; let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; let __v_207: G = __r_arr[18]; let __v_208: G = __r_arr[19]; let __v_209: G = __r_arr[20]; let __v_210: G = __r_arr[21]; let __v_211: G = __r_arr[22]; let __v_212: G = __r_arr[23]; let __v_213: G = __r_arr[24]; let __v_214: G = __r_arr[25]; let __v_215: G = __r_arr[26]; let __v_216: G = __r_arr[27]; let __v_217: G = __r_arr[28]; let __v_218: G = __r_arr[29]; let __v_219: G = __r_arr[30]; let __v_220: G = __r_arr[31]; let __v_221: G = { let __values: [G; 34] = [__v_172, __v_102, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_172, __v_221]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(64); let __v_172: G = G::from_u64(103); let __v_173: G = G::from_u64(230); let __v_174: G = G::from_u64(9); let __v_175: G = G::from_u64(106); let __v_176: G = G::from_u64(133); let __v_177: G = G::from_u64(174); let __v_178: G = G::from_u64(187); let __v_179: G = G::from_u64(114); let __v_180: G = G::from_u64(243); let __v_181: G = G::from_u64(110); let __v_182: G = G::from_u64(60); let __v_183: G = G::from_u64(58); let __v_184: G = G::from_u64(245); let __v_185: G = G::from_u64(79); let __v_186: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_170, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_105, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_172, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_171, __v_170, __v_170, __v_170, __v_103, __v_170, __v_170, __v_170, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; let __v_190: G = __r_arr[3]; let __v_191: G = __r_arr[4]; let __v_192: G = __r_arr[5]; let __v_193: G = __r_arr[6]; let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; let __v_197: G = __r_arr[10]; let __v_198: G = __r_arr[11]; let __v_199: G = __r_arr[12]; let __v_200: G = __r_arr[13]; let __v_201: G = __r_arr[14]; let __v_202: G = __r_arr[15]; let __v_203: G = __r_arr[16]; let __v_204: G = __r_arr[17]; let __v_205: G = __r_arr[18]; let __v_206: G = __r_arr[19]; let __v_207: G = __r_arr[20]; let __v_208: G = __r_arr[21]; let __v_209: G = __r_arr[22]; let __v_210: G = __r_arr[23]; let __v_211: G = __r_arr[24]; let __v_212: G = __r_arr[25]; let __v_213: G = __r_arr[26]; let __v_214: G = __r_arr[27]; let __v_215: G = __r_arr[28]; let __v_216: G = __r_arr[29]; let __v_217: G = __r_arr[30]; let __v_218: G = __r_arr[31]; let __v_219: G = { let __values: [G; 34] = [__v_170, __v_102, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_73] = [__v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_170, __v_219]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } const INPUT_SIZE_74: usize = 1; const IN_74: usize = 1; const OUT_74: usize = 32; -fn aiur_fn_74(inp: [G; IN_74], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; let __v_67: G = __loaded[32]; let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_74] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(73, (&__args[..]))?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { (*(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73])) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; let __v_73: G = __r_arr[3]; let __v_74: G = __r_arr[4]; let __v_75: G = __r_arr[5]; let __v_76: G = __r_arr[6]; let __v_77: G = __r_arr[7]; let __v_78: G = __r_arr[8]; let __v_79: G = __r_arr[9]; let __v_80: G = __r_arr[10]; let __v_81: G = __r_arr[11]; let __v_82: G = __r_arr[12]; let __v_83: G = __r_arr[13]; let __v_84: G = __r_arr[14]; let __v_85: G = __r_arr[15]; let __v_86: G = __r_arr[16]; let __v_87: G = __r_arr[17]; let __v_88: G = __r_arr[18]; let __v_89: G = __r_arr[19]; let __v_90: G = __r_arr[20]; let __v_91: G = __r_arr[21]; let __v_92: G = __r_arr[22]; let __v_93: G = __r_arr[23]; let __v_94: G = __r_arr[24]; let __v_95: G = __r_arr[25]; let __v_96: G = __r_arr[26]; let __v_97: G = __r_arr[27]; let __v_98: G = __r_arr[28]; let __v_99: G = __r_arr[29]; let __v_100: G = __r_arr[30]; let __v_101: G = __r_arr[31]; let __v_102: G = __r_arr[32]; let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; let __v_107: G = __r_arr[3]; let __v_108: G = __r_arr[4]; let __v_109: G = __r_arr[5]; let __v_110: G = __r_arr[6]; let __v_111: G = __r_arr[7]; let __v_112: G = __r_arr[8]; let __v_113: G = __r_arr[9]; let __v_114: G = __r_arr[10]; let __v_115: G = __r_arr[11]; let __v_116: G = __r_arr[12]; let __v_117: G = __r_arr[13]; let __v_118: G = __r_arr[14]; let __v_119: G = __r_arr[15]; let __v_120: G = __r_arr[16]; let __v_121: G = __r_arr[17]; let __v_122: G = __r_arr[18]; let __v_123: G = __r_arr[19]; let __v_124: G = __r_arr[20]; let __v_125: G = __r_arr[21]; let __v_126: G = __r_arr[22]; let __v_127: G = __r_arr[23]; let __v_128: G = __r_arr[24]; let __v_129: G = __r_arr[25]; let __v_130: G = __r_arr[26]; let __v_131: G = __r_arr[27]; let __v_132: G = __r_arr[28]; let __v_133: G = __r_arr[29]; let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_74] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; let __v_109: G = __r_arr[3]; let __v_110: G = __r_arr[4]; let __v_111: G = __r_arr[5]; let __v_112: G = __r_arr[6]; let __v_113: G = __r_arr[7]; let __v_114: G = __r_arr[8]; let __v_115: G = __r_arr[9]; let __v_116: G = __r_arr[10]; let __v_117: G = __r_arr[11]; let __v_118: G = __r_arr[12]; let __v_119: G = __r_arr[13]; let __v_120: G = __r_arr[14]; let __v_121: G = __r_arr[15]; let __v_122: G = __r_arr[16]; let __v_123: G = __r_arr[17]; let __v_124: G = __r_arr[18]; let __v_125: G = __r_arr[19]; let __v_126: G = __r_arr[20]; let __v_127: G = __r_arr[21]; let __v_128: G = __r_arr[22]; let __v_129: G = __r_arr[23]; let __v_130: G = __r_arr[24]; let __v_131: G = __r_arr[25]; let __v_132: G = __r_arr[26]; let __v_133: G = __r_arr[27]; let __v_134: G = __r_arr[28]; let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_74] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; record.function_queries[74].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_74(inp: [G; IN_74], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; let __v_67: G = __loaded[32]; let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_74] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(73, &__args[..])?) { [G::ZERO; OUT_73] } else { let (__hash, __hit) = record.function_queries[73].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[73].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => { aiur_fn_73::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; let __v_73: G = __r_arr[3]; let __v_74: G = __r_arr[4]; let __v_75: G = __r_arr[5]; let __v_76: G = __r_arr[6]; let __v_77: G = __r_arr[7]; let __v_78: G = __r_arr[8]; let __v_79: G = __r_arr[9]; let __v_80: G = __r_arr[10]; let __v_81: G = __r_arr[11]; let __v_82: G = __r_arr[12]; let __v_83: G = __r_arr[13]; let __v_84: G = __r_arr[14]; let __v_85: G = __r_arr[15]; let __v_86: G = __r_arr[16]; let __v_87: G = __r_arr[17]; let __v_88: G = __r_arr[18]; let __v_89: G = __r_arr[19]; let __v_90: G = __r_arr[20]; let __v_91: G = __r_arr[21]; let __v_92: G = __r_arr[22]; let __v_93: G = __r_arr[23]; let __v_94: G = __r_arr[24]; let __v_95: G = __r_arr[25]; let __v_96: G = __r_arr[26]; let __v_97: G = __r_arr[27]; let __v_98: G = __r_arr[28]; let __v_99: G = __r_arr[29]; let __v_100: G = __r_arr[30]; let __v_101: G = __r_arr[31]; let __v_102: G = __r_arr[32]; let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; let __v_107: G = __r_arr[3]; let __v_108: G = __r_arr[4]; let __v_109: G = __r_arr[5]; let __v_110: G = __r_arr[6]; let __v_111: G = __r_arr[7]; let __v_112: G = __r_arr[8]; let __v_113: G = __r_arr[9]; let __v_114: G = __r_arr[10]; let __v_115: G = __r_arr[11]; let __v_116: G = __r_arr[12]; let __v_117: G = __r_arr[13]; let __v_118: G = __r_arr[14]; let __v_119: G = __r_arr[15]; let __v_120: G = __r_arr[16]; let __v_121: G = __r_arr[17]; let __v_122: G = __r_arr[18]; let __v_123: G = __r_arr[19]; let __v_124: G = __r_arr[20]; let __v_125: G = __r_arr[21]; let __v_126: G = __r_arr[22]; let __v_127: G = __r_arr[23]; let __v_128: G = __r_arr[24]; let __v_129: G = __r_arr[25]; let __v_130: G = __r_arr[26]; let __v_131: G = __r_arr[27]; let __v_132: G = __r_arr[28]; let __v_133: G = __r_arr[29]; let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_74] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; let __v_109: G = __r_arr[3]; let __v_110: G = __r_arr[4]; let __v_111: G = __r_arr[5]; let __v_112: G = __r_arr[6]; let __v_113: G = __r_arr[7]; let __v_114: G = __r_arr[8]; let __v_115: G = __r_arr[9]; let __v_116: G = __r_arr[10]; let __v_117: G = __r_arr[11]; let __v_118: G = __r_arr[12]; let __v_119: G = __r_arr[13]; let __v_120: G = __r_arr[14]; let __v_121: G = __r_arr[15]; let __v_122: G = __r_arr[16]; let __v_123: G = __r_arr[17]; let __v_124: G = __r_arr[18]; let __v_125: G = __r_arr[19]; let __v_126: G = __r_arr[20]; let __v_127: G = __r_arr[21]; let __v_128: G = __r_arr[22]; let __v_129: G = __r_arr[23]; let __v_130: G = __r_arr[24]; let __v_131: G = __r_arr[25]; let __v_132: G = __r_arr[26]; let __v_133: G = __r_arr[27]; let __v_134: G = __r_arr[28]; let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_74] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_75: usize = 7; const IN_75: usize = 7; const OUT_75: usize = 1; -fn aiur_fn_75(inp: [G; IN_75], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, (&__args[..]))?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { (*(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78])) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_10]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, (&__args[..]))?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { (*(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79])) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_12]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 + __v_12); let __v_14: G = (__v_3 + __v_12); let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_15]; record.function_queries[75].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_75(inp: [G; IN_75], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(78, &__args[..])?) { [G::ZERO; OUT_78] } else { let (__hash, __hit) = record.function_queries[78].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[78].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => { aiur_fn_78::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_10]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; match __v_2.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(79, &__args[..])?) { [G::ZERO; OUT_79] } else { let (__hash, __hit) = record.function_queries[79].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[79].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => { aiur_fn_79::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_12]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = __v_2 + __v_12; let __v_14: G = __v_3 + __v_12; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_15]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_76: usize = 1; const IN_76: usize = 1; const OUT_76: usize = 64; -fn aiur_fn_76(inp: [G; IN_76], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_76] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[76].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_76(inp: [G; IN_76], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_76] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_77: usize = 2; const IN_77: usize = 2; const OUT_77: usize = 1; -fn aiur_fn_77(inp: [G; IN_77], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_77] = [__v_0]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_6]; record.function_queries[77].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_77(inp: [G; IN_77], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_77] = [__v_0]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_6]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_78: usize = 6; const IN_78: usize = 6; const OUT_78: usize = 1; -fn aiur_fn_78(inp: [G; IN_78], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = __loaded[18]; let __v_38: G = __loaded[19]; let __v_39: G = __loaded[20]; let __v_40: G = __loaded[21]; let __v_41: G = __loaded[22]; let __v_42: G = __loaded[23]; let __v_43: G = __loaded[24]; let __v_44: G = __loaded[25]; let __v_45: G = __loaded[26]; let __v_46: G = __loaded[27]; let __v_47: G = __loaded[28]; let __v_48: G = __loaded[29]; let __v_49: G = __loaded[30]; let __v_50: G = __loaded[31]; let __v_51: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; let __v_55: G = __loaded[3]; let __v_56: G = __loaded[4]; let __v_57: G = __loaded[5]; let __v_58: G = __loaded[6]; let __v_59: G = __loaded[7]; let __v_60: G = G::from_u64(103); let __v_61: G = G::from_u64(230); let __v_62: G = G::from_u64(9); let __v_63: G = G::from_u64(106); let __v_64: G = G::from_u64(133); let __v_65: G = G::from_u64(174); let __v_66: G = G::from_u64(187); let __v_67: G = G::from_u64(114); let __v_68: G = G::from_u64(243); let __v_69: G = G::from_u64(110); let __v_70: G = G::from_u64(60); let __v_71: G = G::from_u64(58); let __v_72: G = G::from_u64(245); let __v_73: G = G::from_u64(79); let __v_74: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_51, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_60, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_51, __v_51, __v_51, __v_51, __v_18, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; let __v_79: G = __r_arr[4]; let __v_80: G = __r_arr[5]; let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; let __v_84: G = __r_arr[9]; let __v_85: G = __r_arr[10]; let __v_86: G = __r_arr[11]; let __v_87: G = __r_arr[12]; let __v_88: G = __r_arr[13]; let __v_89: G = __r_arr[14]; let __v_90: G = __r_arr[15]; let __v_91: G = __r_arr[16]; let __v_92: G = __r_arr[17]; let __v_93: G = __r_arr[18]; let __v_94: G = __r_arr[19]; let __v_95: G = __r_arr[20]; let __v_96: G = __r_arr[21]; let __v_97: G = __r_arr[22]; let __v_98: G = __r_arr[23]; let __v_99: G = __r_arr[24]; let __v_100: G = __r_arr[25]; let __v_101: G = __r_arr[26]; let __v_102: G = __r_arr[27]; let __v_103: G = __r_arr[28]; let __v_104: G = __r_arr[29]; let __v_105: G = __r_arr[30]; let __v_106: G = __r_arr[31]; let __v_107: G = { let __values: [G; 34] = [__v_51, __v_5, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_107]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __v_28: G = __loaded[18]; let __v_29: G = __loaded[19]; let __v_30: G = __loaded[20]; let __v_31: G = __loaded[21]; let __v_32: G = __loaded[22]; let __v_33: G = __loaded[23]; let __v_34: G = __loaded[24]; let __v_35: G = __loaded[25]; let __v_36: G = __loaded[26]; let __v_37: G = __loaded[27]; let __v_38: G = __loaded[28]; let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_42]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = (__v_20 * __v_6); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, (&__args[..]))?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { (*(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77])) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, (&__args[..]))?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { (*(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76])) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __v_33: G = __r_arr[6]; let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __v_37: G = __r_arr[10]; let __v_38: G = __r_arr[11]; let __v_39: G = __r_arr[12]; let __v_40: G = __r_arr[13]; let __v_41: G = __r_arr[14]; let __v_42: G = __r_arr[15]; let __v_43: G = __r_arr[16]; let __v_44: G = __r_arr[17]; let __v_45: G = __r_arr[18]; let __v_46: G = __r_arr[19]; let __v_47: G = __r_arr[20]; let __v_48: G = __r_arr[21]; let __v_49: G = __r_arr[22]; let __v_50: G = __r_arr[23]; let __v_51: G = __r_arr[24]; let __v_52: G = __r_arr[25]; let __v_53: G = __r_arr[26]; let __v_54: G = __r_arr[27]; let __v_55: G = __r_arr[28]; let __v_56: G = __r_arr[29]; let __v_57: G = __r_arr[30]; let __v_58: G = __r_arr[31]; let __v_59: G = __r_arr[32]; let __v_60: G = __r_arr[33]; let __v_61: G = __r_arr[34]; let __v_62: G = __r_arr[35]; let __v_63: G = __r_arr[36]; let __v_64: G = __r_arr[37]; let __v_65: G = __r_arr[38]; let __v_66: G = __r_arr[39]; let __v_67: G = __r_arr[40]; let __v_68: G = __r_arr[41]; let __v_69: G = __r_arr[42]; let __v_70: G = __r_arr[43]; let __v_71: G = __r_arr[44]; let __v_72: G = __r_arr[45]; let __v_73: G = __r_arr[46]; let __v_74: G = __r_arr[47]; let __v_75: G = __r_arr[48]; let __v_76: G = __r_arr[49]; let __v_77: G = __r_arr[50]; let __v_78: G = __r_arr[51]; let __v_79: G = __r_arr[52]; let __v_80: G = __r_arr[53]; let __v_81: G = __r_arr[54]; let __v_82: G = __r_arr[55]; let __v_83: G = __r_arr[56]; let __v_84: G = __r_arr[57]; let __v_85: G = __r_arr[58]; let __v_86: G = __r_arr[59]; let __v_87: G = __r_arr[60]; let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; let __v_94: G = __loaded[3]; let __v_95: G = __loaded[4]; let __v_96: G = __loaded[5]; let __v_97: G = __loaded[6]; let __v_98: G = __loaded[7]; let __v_99: G = __loaded[8]; let __v_100: G = __loaded[9]; let __v_101: G = __loaded[10]; let __v_102: G = __loaded[11]; let __v_103: G = __loaded[12]; let __v_104: G = __loaded[13]; let __v_105: G = __loaded[14]; let __v_106: G = __loaded[15]; let __v_107: G = __loaded[16]; let __v_108: G = __loaded[17]; let __v_109: G = __loaded[18]; let __v_110: G = __loaded[19]; let __v_111: G = __loaded[20]; let __v_112: G = __loaded[21]; let __v_113: G = __loaded[22]; let __v_114: G = __loaded[23]; let __v_115: G = __loaded[24]; let __v_116: G = __loaded[25]; let __v_117: G = __loaded[26]; let __v_118: G = __loaded[27]; let __v_119: G = __loaded[28]; let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; let __v_123: G = G::from_u64(103); let __v_124: G = G::from_u64(230); let __v_125: G = G::from_u64(9); let __v_126: G = G::from_u64(106); let __v_127: G = G::from_u64(133); let __v_128: G = G::from_u64(174); let __v_129: G = G::from_u64(187); let __v_130: G = G::from_u64(114); let __v_131: G = G::from_u64(243); let __v_132: G = G::from_u64(110); let __v_133: G = G::from_u64(60); let __v_134: G = G::from_u64(58); let __v_135: G = G::from_u64(245); let __v_136: G = G::from_u64(79); let __v_137: G = G::from_u64(165); let __v_138: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_138, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_123, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_138, __v_138, __v_138, __v_23, __v_138, __v_138, __v_138, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; let __v_141: G = __r_arr[2]; let __v_142: G = __r_arr[3]; let __v_143: G = __r_arr[4]; let __v_144: G = __r_arr[5]; let __v_145: G = __r_arr[6]; let __v_146: G = __r_arr[7]; let __v_147: G = __r_arr[8]; let __v_148: G = __r_arr[9]; let __v_149: G = __r_arr[10]; let __v_150: G = __r_arr[11]; let __v_151: G = __r_arr[12]; let __v_152: G = __r_arr[13]; let __v_153: G = __r_arr[14]; let __v_154: G = __r_arr[15]; let __v_155: G = __r_arr[16]; let __v_156: G = __r_arr[17]; let __v_157: G = __r_arr[18]; let __v_158: G = __r_arr[19]; let __v_159: G = __r_arr[20]; let __v_160: G = __r_arr[21]; let __v_161: G = __r_arr[22]; let __v_162: G = __r_arr[23]; let __v_163: G = __r_arr[24]; let __v_164: G = __r_arr[25]; let __v_165: G = __r_arr[26]; let __v_166: G = __r_arr[27]; let __v_167: G = __r_arr[28]; let __v_168: G = __r_arr[29]; let __v_169: G = __r_arr[30]; let __v_170: G = __r_arr[31]; let __v_171: G = { let __values: [G; 34] = [__v_138, __v_5, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_171]; record.function_queries[78].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_78(inp: [G; IN_78], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; match __v_9.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = __v_6 + __v_7; let __v_18: G = __v_8 + __v_17; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = __loaded[18]; let __v_38: G = __loaded[19]; let __v_39: G = __loaded[20]; let __v_40: G = __loaded[21]; let __v_41: G = __loaded[22]; let __v_42: G = __loaded[23]; let __v_43: G = __loaded[24]; let __v_44: G = __loaded[25]; let __v_45: G = __loaded[26]; let __v_46: G = __loaded[27]; let __v_47: G = __loaded[28]; let __v_48: G = __loaded[29]; let __v_49: G = __loaded[30]; let __v_50: G = __loaded[31]; let __v_51: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; let __v_55: G = __loaded[3]; let __v_56: G = __loaded[4]; let __v_57: G = __loaded[5]; let __v_58: G = __loaded[6]; let __v_59: G = __loaded[7]; let __v_60: G = G::from_u64(103); let __v_61: G = G::from_u64(230); let __v_62: G = G::from_u64(9); let __v_63: G = G::from_u64(106); let __v_64: G = G::from_u64(133); let __v_65: G = G::from_u64(174); let __v_66: G = G::from_u64(187); let __v_67: G = G::from_u64(114); let __v_68: G = G::from_u64(243); let __v_69: G = G::from_u64(110); let __v_70: G = G::from_u64(60); let __v_71: G = G::from_u64(58); let __v_72: G = G::from_u64(245); let __v_73: G = G::from_u64(79); let __v_74: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_51, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_60, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_51, __v_51, __v_51, __v_51, __v_18, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; let __v_79: G = __r_arr[4]; let __v_80: G = __r_arr[5]; let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; let __v_84: G = __r_arr[9]; let __v_85: G = __r_arr[10]; let __v_86: G = __r_arr[11]; let __v_87: G = __r_arr[12]; let __v_88: G = __r_arr[13]; let __v_89: G = __r_arr[14]; let __v_90: G = __r_arr[15]; let __v_91: G = __r_arr[16]; let __v_92: G = __r_arr[17]; let __v_93: G = __r_arr[18]; let __v_94: G = __r_arr[19]; let __v_95: G = __r_arr[20]; let __v_96: G = __r_arr[21]; let __v_97: G = __r_arr[22]; let __v_98: G = __r_arr[23]; let __v_99: G = __r_arr[24]; let __v_100: G = __r_arr[25]; let __v_101: G = __r_arr[26]; let __v_102: G = __r_arr[27]; let __v_103: G = __r_arr[28]; let __v_104: G = __r_arr[29]; let __v_105: G = __r_arr[30]; let __v_106: G = __r_arr[31]; let __v_107: G = { let __values: [G; 34] = [__v_51, __v_5, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_107]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_78] = [__v_5]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __v_28: G = __loaded[18]; let __v_29: G = __loaded[19]; let __v_30: G = __loaded[20]; let __v_31: G = __loaded[21]; let __v_32: G = __loaded[22]; let __v_33: G = __loaded[23]; let __v_34: G = __loaded[24]; let __v_35: G = __loaded[25]; let __v_36: G = __loaded[26]; let __v_37: G = __loaded[27]; let __v_38: G = __loaded[28]; let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_42]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_17 * __v_8; let __v_19: G = __v_2 - __v_1; let __v_20: G = G::from_bool(__v_19 == G::ZERO); let __v_21: G = __v_20 * __v_6; let __v_22: G = __v_18 + __v_21; let __v_23: G = __v_7 + __v_22; let __v_24: G = G::from_u64(64); let __v_25: G = __v_24 - __v_1; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(77, &__args[..])?) { [G::ZERO; OUT_77] } else { let (__hash, __hit) = record.function_queries[77].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[77].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => { aiur_fn_77::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, &__args[..])?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __v_33: G = __r_arr[6]; let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __v_37: G = __r_arr[10]; let __v_38: G = __r_arr[11]; let __v_39: G = __r_arr[12]; let __v_40: G = __r_arr[13]; let __v_41: G = __r_arr[14]; let __v_42: G = __r_arr[15]; let __v_43: G = __r_arr[16]; let __v_44: G = __r_arr[17]; let __v_45: G = __r_arr[18]; let __v_46: G = __r_arr[19]; let __v_47: G = __r_arr[20]; let __v_48: G = __r_arr[21]; let __v_49: G = __r_arr[22]; let __v_50: G = __r_arr[23]; let __v_51: G = __r_arr[24]; let __v_52: G = __r_arr[25]; let __v_53: G = __r_arr[26]; let __v_54: G = __r_arr[27]; let __v_55: G = __r_arr[28]; let __v_56: G = __r_arr[29]; let __v_57: G = __r_arr[30]; let __v_58: G = __r_arr[31]; let __v_59: G = __r_arr[32]; let __v_60: G = __r_arr[33]; let __v_61: G = __r_arr[34]; let __v_62: G = __r_arr[35]; let __v_63: G = __r_arr[36]; let __v_64: G = __r_arr[37]; let __v_65: G = __r_arr[38]; let __v_66: G = __r_arr[39]; let __v_67: G = __r_arr[40]; let __v_68: G = __r_arr[41]; let __v_69: G = __r_arr[42]; let __v_70: G = __r_arr[43]; let __v_71: G = __r_arr[44]; let __v_72: G = __r_arr[45]; let __v_73: G = __r_arr[46]; let __v_74: G = __r_arr[47]; let __v_75: G = __r_arr[48]; let __v_76: G = __r_arr[49]; let __v_77: G = __r_arr[50]; let __v_78: G = __r_arr[51]; let __v_79: G = __r_arr[52]; let __v_80: G = __r_arr[53]; let __v_81: G = __r_arr[54]; let __v_82: G = __r_arr[55]; let __v_83: G = __r_arr[56]; let __v_84: G = __r_arr[57]; let __v_85: G = __r_arr[58]; let __v_86: G = __r_arr[59]; let __v_87: G = __r_arr[60]; let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; let __v_94: G = __loaded[3]; let __v_95: G = __loaded[4]; let __v_96: G = __loaded[5]; let __v_97: G = __loaded[6]; let __v_98: G = __loaded[7]; let __v_99: G = __loaded[8]; let __v_100: G = __loaded[9]; let __v_101: G = __loaded[10]; let __v_102: G = __loaded[11]; let __v_103: G = __loaded[12]; let __v_104: G = __loaded[13]; let __v_105: G = __loaded[14]; let __v_106: G = __loaded[15]; let __v_107: G = __loaded[16]; let __v_108: G = __loaded[17]; let __v_109: G = __loaded[18]; let __v_110: G = __loaded[19]; let __v_111: G = __loaded[20]; let __v_112: G = __loaded[21]; let __v_113: G = __loaded[22]; let __v_114: G = __loaded[23]; let __v_115: G = __loaded[24]; let __v_116: G = __loaded[25]; let __v_117: G = __loaded[26]; let __v_118: G = __loaded[27]; let __v_119: G = __loaded[28]; let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; let __v_123: G = G::from_u64(103); let __v_124: G = G::from_u64(230); let __v_125: G = G::from_u64(9); let __v_126: G = G::from_u64(106); let __v_127: G = G::from_u64(133); let __v_128: G = G::from_u64(174); let __v_129: G = G::from_u64(187); let __v_130: G = G::from_u64(114); let __v_131: G = G::from_u64(243); let __v_132: G = G::from_u64(110); let __v_133: G = G::from_u64(60); let __v_134: G = G::from_u64(58); let __v_135: G = G::from_u64(245); let __v_136: G = G::from_u64(79); let __v_137: G = G::from_u64(165); let __v_138: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_138, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_123, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_138, __v_138, __v_138, __v_23, __v_138, __v_138, __v_138, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; let __v_141: G = __r_arr[2]; let __v_142: G = __r_arr[3]; let __v_143: G = __r_arr[4]; let __v_144: G = __r_arr[5]; let __v_145: G = __r_arr[6]; let __v_146: G = __r_arr[7]; let __v_147: G = __r_arr[8]; let __v_148: G = __r_arr[9]; let __v_149: G = __r_arr[10]; let __v_150: G = __r_arr[11]; let __v_151: G = __r_arr[12]; let __v_152: G = __r_arr[13]; let __v_153: G = __r_arr[14]; let __v_154: G = __r_arr[15]; let __v_155: G = __r_arr[16]; let __v_156: G = __r_arr[17]; let __v_157: G = __r_arr[18]; let __v_158: G = __r_arr[19]; let __v_159: G = __r_arr[20]; let __v_160: G = __r_arr[21]; let __v_161: G = __r_arr[22]; let __v_162: G = __r_arr[23]; let __v_163: G = __r_arr[24]; let __v_164: G = __r_arr[25]; let __v_165: G = __r_arr[26]; let __v_166: G = __r_arr[27]; let __v_167: G = __r_arr[28]; let __v_168: G = __r_arr[29]; let __v_169: G = __r_arr[30]; let __v_170: G = __r_arr[31]; let __v_171: G = { let __values: [G; 34] = [__v_138, __v_5, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_78] = [__v_171]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_79: usize = 6; const IN_79: usize = 6; const OUT_79: usize = 1; -fn aiur_fn_79(inp: [G; IN_79], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, (&__args[..]))?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { (*(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76])) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __v_18: G = __r_arr[9]; let __v_19: G = __r_arr[10]; let __v_20: G = __r_arr[11]; let __v_21: G = __r_arr[12]; let __v_22: G = __r_arr[13]; let __v_23: G = __r_arr[14]; let __v_24: G = __r_arr[15]; let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; let __v_28: G = __r_arr[19]; let __v_29: G = __r_arr[20]; let __v_30: G = __r_arr[21]; let __v_31: G = __r_arr[22]; let __v_32: G = __r_arr[23]; let __v_33: G = __r_arr[24]; let __v_34: G = __r_arr[25]; let __v_35: G = __r_arr[26]; let __v_36: G = __r_arr[27]; let __v_37: G = __r_arr[28]; let __v_38: G = __r_arr[29]; let __v_39: G = __r_arr[30]; let __v_40: G = __r_arr[31]; let __v_41: G = __r_arr[32]; let __v_42: G = __r_arr[33]; let __v_43: G = __r_arr[34]; let __v_44: G = __r_arr[35]; let __v_45: G = __r_arr[36]; let __v_46: G = __r_arr[37]; let __v_47: G = __r_arr[38]; let __v_48: G = __r_arr[39]; let __v_49: G = __r_arr[40]; let __v_50: G = __r_arr[41]; let __v_51: G = __r_arr[42]; let __v_52: G = __r_arr[43]; let __v_53: G = __r_arr[44]; let __v_54: G = __r_arr[45]; let __v_55: G = __r_arr[46]; let __v_56: G = __r_arr[47]; let __v_57: G = __r_arr[48]; let __v_58: G = __r_arr[49]; let __v_59: G = __r_arr[50]; let __v_60: G = __r_arr[51]; let __v_61: G = __r_arr[52]; let __v_62: G = __r_arr[53]; let __v_63: G = __r_arr[54]; let __v_64: G = __r_arr[55]; let __v_65: G = __r_arr[56]; let __v_66: G = __r_arr[57]; let __v_67: G = __r_arr[58]; let __v_68: G = __r_arr[59]; let __v_69: G = __r_arr[60]; let __v_70: G = __r_arr[61]; let __v_71: G = __r_arr[62]; let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; let __v_77: G = __loaded[3]; let __v_78: G = __loaded[4]; let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); let __v_85: G = (__v_84 + __v_7); let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_117: G = __loaded[0]; let __v_118: G = __loaded[1]; let __v_119: G = __loaded[2]; let __v_120: G = __loaded[3]; let __v_121: G = __loaded[4]; let __v_122: G = __loaded[5]; let __v_123: G = __loaded[6]; let __v_124: G = __loaded[7]; let __v_125: G = __loaded[8]; let __v_126: G = __loaded[9]; let __v_127: G = __loaded[10]; let __v_128: G = __loaded[11]; let __v_129: G = __loaded[12]; let __v_130: G = __loaded[13]; let __v_131: G = __loaded[14]; let __v_132: G = __loaded[15]; let __v_133: G = __loaded[16]; let __v_134: G = __loaded[17]; let __v_135: G = __loaded[18]; let __v_136: G = __loaded[19]; let __v_137: G = __loaded[20]; let __v_138: G = __loaded[21]; let __v_139: G = __loaded[22]; let __v_140: G = __loaded[23]; let __v_141: G = __loaded[24]; let __v_142: G = __loaded[25]; let __v_143: G = __loaded[26]; let __v_144: G = __loaded[27]; let __v_145: G = __loaded[28]; let __v_146: G = __loaded[29]; let __v_147: G = __loaded[30]; let __v_148: G = __loaded[31]; let __v_149: G = G::from_u64(64); let __v_150: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_149, __v_150, __v_150, __v_150, __v_85, __v_150, __v_150, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; let __v_154: G = __r_arr[3]; let __v_155: G = __r_arr[4]; let __v_156: G = __r_arr[5]; let __v_157: G = __r_arr[6]; let __v_158: G = __r_arr[7]; let __v_159: G = __r_arr[8]; let __v_160: G = __r_arr[9]; let __v_161: G = __r_arr[10]; let __v_162: G = __r_arr[11]; let __v_163: G = __r_arr[12]; let __v_164: G = __r_arr[13]; let __v_165: G = __r_arr[14]; let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; let __v_169: G = __r_arr[18]; let __v_170: G = __r_arr[19]; let __v_171: G = __r_arr[20]; let __v_172: G = __r_arr[21]; let __v_173: G = __r_arr[22]; let __v_174: G = __r_arr[23]; let __v_175: G = __r_arr[24]; let __v_176: G = __r_arr[25]; let __v_177: G = __r_arr[26]; let __v_178: G = __r_arr[27]; let __v_179: G = __r_arr[28]; let __v_180: G = __r_arr[29]; let __v_181: G = __r_arr[30]; let __v_182: G = __r_arr[31]; let __v_183: G = { let __values: [G; 34] = [__v_150, __v_5, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_184: G = G::from_u64(1); let __v_185: G = { let __values: [G; 3] = [__v_184, __v_184, __v_184]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, (&__args[..]))?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { (*(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11])) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = __r_arr[3]; let __v_190: G = __r_arr[4]; let __v_191: G = __r_arr[5]; let __v_192: G = __r_arr[6]; let __v_193: G = __r_arr[7]; let __v_194: G = { let __values: [G; 8] = [__v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_195: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_196]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, (&__args[..]))?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { (*(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249])) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; let __v_79: G = __loaded[3]; let __v_80: G = __loaded[4]; let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); let __v_87: G = G::from_u64(63); let __v_88: G = (__v_2 - __v_87); let __v_89: G = G::from_bool((__v_88 == G::ZERO)); let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; let __v_96: G = __loaded[3]; let __v_97: G = __loaded[4]; let __v_98: G = __loaded[5]; let __v_99: G = __loaded[6]; let __v_100: G = __loaded[7]; let __v_101: G = __loaded[8]; let __v_102: G = __loaded[9]; let __v_103: G = __loaded[10]; let __v_104: G = __loaded[11]; let __v_105: G = __loaded[12]; let __v_106: G = __loaded[13]; let __v_107: G = __loaded[14]; let __v_108: G = __loaded[15]; let __v_109: G = __loaded[16]; let __v_110: G = __loaded[17]; let __v_111: G = __loaded[18]; let __v_112: G = __loaded[19]; let __v_113: G = __loaded[20]; let __v_114: G = __loaded[21]; let __v_115: G = __loaded[22]; let __v_116: G = __loaded[23]; let __v_117: G = __loaded[24]; let __v_118: G = __loaded[25]; let __v_119: G = __loaded[26]; let __v_120: G = __loaded[27]; let __v_121: G = __loaded[28]; let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; let __v_125: G = G::from_u64(64); let __v_126: G = G::from_u64(103); let __v_127: G = G::from_u64(230); let __v_128: G = G::from_u64(9); let __v_129: G = G::from_u64(106); let __v_130: G = G::from_u64(133); let __v_131: G = G::from_u64(174); let __v_132: G = G::from_u64(187); let __v_133: G = G::from_u64(114); let __v_134: G = G::from_u64(243); let __v_135: G = G::from_u64(110); let __v_136: G = G::from_u64(60); let __v_137: G = G::from_u64(58); let __v_138: G = G::from_u64(245); let __v_139: G = G::from_u64(79); let __v_140: G = G::from_u64(165); let __v_141: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_141, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_126, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_125, __v_141, __v_141, __v_141, __v_92, __v_141, __v_141, __v_141, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __v_152: G = __r_arr[10]; let __v_153: G = __r_arr[11]; let __v_154: G = __r_arr[12]; let __v_155: G = __r_arr[13]; let __v_156: G = __r_arr[14]; let __v_157: G = __r_arr[15]; let __v_158: G = __r_arr[16]; let __v_159: G = __r_arr[17]; let __v_160: G = __r_arr[18]; let __v_161: G = __r_arr[19]; let __v_162: G = __r_arr[20]; let __v_163: G = __r_arr[21]; let __v_164: G = __r_arr[22]; let __v_165: G = __r_arr[23]; let __v_166: G = __r_arr[24]; let __v_167: G = __r_arr[25]; let __v_168: G = __r_arr[26]; let __v_169: G = __r_arr[27]; let __v_170: G = __r_arr[28]; let __v_171: G = __r_arr[29]; let __v_172: G = __r_arr[30]; let __v_173: G = __r_arr[31]; let __v_174: G = G::from_u64(1); let __v_175: G = { let __values: [G; 3] = [__v_174, __v_174, __v_174]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_176: G = (__v_2 + __v_174); let __v_177: G = { let __values: [G; 32] = [__v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_178]; record.function_queries[79].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_79(inp: [G; IN_79], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(76, &__args[..])?) { [G::ZERO; OUT_76] } else { let (__hash, __hit) = record.function_queries[76].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[76].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => { aiur_fn_76::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = __r_arr[3]; let __v_13: G = __r_arr[4]; let __v_14: G = __r_arr[5]; let __v_15: G = __r_arr[6]; let __v_16: G = __r_arr[7]; let __v_17: G = __r_arr[8]; let __v_18: G = __r_arr[9]; let __v_19: G = __r_arr[10]; let __v_20: G = __r_arr[11]; let __v_21: G = __r_arr[12]; let __v_22: G = __r_arr[13]; let __v_23: G = __r_arr[14]; let __v_24: G = __r_arr[15]; let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; let __v_28: G = __r_arr[19]; let __v_29: G = __r_arr[20]; let __v_30: G = __r_arr[21]; let __v_31: G = __r_arr[22]; let __v_32: G = __r_arr[23]; let __v_33: G = __r_arr[24]; let __v_34: G = __r_arr[25]; let __v_35: G = __r_arr[26]; let __v_36: G = __r_arr[27]; let __v_37: G = __r_arr[28]; let __v_38: G = __r_arr[29]; let __v_39: G = __r_arr[30]; let __v_40: G = __r_arr[31]; let __v_41: G = __r_arr[32]; let __v_42: G = __r_arr[33]; let __v_43: G = __r_arr[34]; let __v_44: G = __r_arr[35]; let __v_45: G = __r_arr[36]; let __v_46: G = __r_arr[37]; let __v_47: G = __r_arr[38]; let __v_48: G = __r_arr[39]; let __v_49: G = __r_arr[40]; let __v_50: G = __r_arr[41]; let __v_51: G = __r_arr[42]; let __v_52: G = __r_arr[43]; let __v_53: G = __r_arr[44]; let __v_54: G = __r_arr[45]; let __v_55: G = __r_arr[46]; let __v_56: G = __r_arr[47]; let __v_57: G = __r_arr[48]; let __v_58: G = __r_arr[49]; let __v_59: G = __r_arr[50]; let __v_60: G = __r_arr[51]; let __v_61: G = __r_arr[52]; let __v_62: G = __r_arr[53]; let __v_63: G = __r_arr[54]; let __v_64: G = __r_arr[55]; let __v_65: G = __r_arr[56]; let __v_66: G = __r_arr[57]; let __v_67: G = __r_arr[58]; let __v_68: G = __r_arr[59]; let __v_69: G = __r_arr[60]; let __v_70: G = __r_arr[61]; let __v_71: G = __r_arr[62]; let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; let __v_77: G = __loaded[3]; let __v_78: G = __loaded[4]; let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __v_73 * __v_82; let __v_84: G = __v_8 * __v_83; let __v_85: G = __v_84 + __v_7; let __v_86: G = G::from_u64(103); let __v_87: G = G::from_u64(230); let __v_88: G = G::from_u64(9); let __v_89: G = G::from_u64(106); let __v_90: G = G::from_u64(133); let __v_91: G = G::from_u64(174); let __v_92: G = G::from_u64(187); let __v_93: G = G::from_u64(114); let __v_94: G = G::from_u64(243); let __v_95: G = G::from_u64(110); let __v_96: G = G::from_u64(60); let __v_97: G = G::from_u64(58); let __v_98: G = G::from_u64(245); let __v_99: G = G::from_u64(79); let __v_100: G = G::from_u64(165); let __v_101: G = G::from_u64(127); let __v_102: G = G::from_u64(82); let __v_103: G = G::from_u64(14); let __v_104: G = G::from_u64(81); let __v_105: G = G::from_u64(140); let __v_106: G = G::from_u64(104); let __v_107: G = G::from_u64(5); let __v_108: G = G::from_u64(155); let __v_109: G = G::from_u64(171); let __v_110: G = G::from_u64(217); let __v_111: G = G::from_u64(131); let __v_112: G = G::from_u64(31); let __v_113: G = G::from_u64(25); let __v_114: G = G::from_u64(205); let __v_115: G = G::from_u64(224); let __v_116: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_117: G = __loaded[0]; let __v_118: G = __loaded[1]; let __v_119: G = __loaded[2]; let __v_120: G = __loaded[3]; let __v_121: G = __loaded[4]; let __v_122: G = __loaded[5]; let __v_123: G = __loaded[6]; let __v_124: G = __loaded[7]; let __v_125: G = __loaded[8]; let __v_126: G = __loaded[9]; let __v_127: G = __loaded[10]; let __v_128: G = __loaded[11]; let __v_129: G = __loaded[12]; let __v_130: G = __loaded[13]; let __v_131: G = __loaded[14]; let __v_132: G = __loaded[15]; let __v_133: G = __loaded[16]; let __v_134: G = __loaded[17]; let __v_135: G = __loaded[18]; let __v_136: G = __loaded[19]; let __v_137: G = __loaded[20]; let __v_138: G = __loaded[21]; let __v_139: G = __loaded[22]; let __v_140: G = __loaded[23]; let __v_141: G = __loaded[24]; let __v_142: G = __loaded[25]; let __v_143: G = __loaded[26]; let __v_144: G = __loaded[27]; let __v_145: G = __loaded[28]; let __v_146: G = __loaded[29]; let __v_147: G = __loaded[30]; let __v_148: G = __loaded[31]; let __v_149: G = G::from_u64(64); let __v_150: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_150, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_149, __v_150, __v_150, __v_150, __v_85, __v_150, __v_150, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; let __v_154: G = __r_arr[3]; let __v_155: G = __r_arr[4]; let __v_156: G = __r_arr[5]; let __v_157: G = __r_arr[6]; let __v_158: G = __r_arr[7]; let __v_159: G = __r_arr[8]; let __v_160: G = __r_arr[9]; let __v_161: G = __r_arr[10]; let __v_162: G = __r_arr[11]; let __v_163: G = __r_arr[12]; let __v_164: G = __r_arr[13]; let __v_165: G = __r_arr[14]; let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; let __v_169: G = __r_arr[18]; let __v_170: G = __r_arr[19]; let __v_171: G = __r_arr[20]; let __v_172: G = __r_arr[21]; let __v_173: G = __r_arr[22]; let __v_174: G = __r_arr[23]; let __v_175: G = __r_arr[24]; let __v_176: G = __r_arr[25]; let __v_177: G = __r_arr[26]; let __v_178: G = __r_arr[27]; let __v_179: G = __r_arr[28]; let __v_180: G = __r_arr[29]; let __v_181: G = __r_arr[30]; let __v_182: G = __r_arr[31]; let __v_183: G = { let __values: [G; 34] = [__v_150, __v_5, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_184: G = G::from_u64(1); let __v_185: G = { let __values: [G; 3] = [__v_184, __v_184, __v_184]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, &__args[..])?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { *(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11]) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = __r_arr[3]; let __v_190: G = __r_arr[4]; let __v_191: G = __r_arr[5]; let __v_192: G = __r_arr[6]; let __v_193: G = __r_arr[7]; let __v_194: G = { let __values: [G; 8] = [__v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_195: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_86, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_196]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __v_73 * __v_7; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(249, &__args[..])?) { [G::ZERO; OUT_249] } else { let (__hash, __hit) = record.function_queries[249].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[249].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => { aiur_fn_249::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; let __v_79: G = __loaded[3]; let __v_80: G = __loaded[4]; let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __v_84 * __v_8; let __v_86: G = __v_75 * __v_85; let __v_87: G = G::from_u64(63); let __v_88: G = __v_2 - __v_87; let __v_89: G = G::from_bool(__v_88 == G::ZERO); let __v_90: G = __v_89 * __v_6; let __v_91: G = __v_86 + __v_90; let __v_92: G = __v_74 + __v_91; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; let __v_96: G = __loaded[3]; let __v_97: G = __loaded[4]; let __v_98: G = __loaded[5]; let __v_99: G = __loaded[6]; let __v_100: G = __loaded[7]; let __v_101: G = __loaded[8]; let __v_102: G = __loaded[9]; let __v_103: G = __loaded[10]; let __v_104: G = __loaded[11]; let __v_105: G = __loaded[12]; let __v_106: G = __loaded[13]; let __v_107: G = __loaded[14]; let __v_108: G = __loaded[15]; let __v_109: G = __loaded[16]; let __v_110: G = __loaded[17]; let __v_111: G = __loaded[18]; let __v_112: G = __loaded[19]; let __v_113: G = __loaded[20]; let __v_114: G = __loaded[21]; let __v_115: G = __loaded[22]; let __v_116: G = __loaded[23]; let __v_117: G = __loaded[24]; let __v_118: G = __loaded[25]; let __v_119: G = __loaded[26]; let __v_120: G = __loaded[27]; let __v_121: G = __loaded[28]; let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; let __v_125: G = G::from_u64(64); let __v_126: G = G::from_u64(103); let __v_127: G = G::from_u64(230); let __v_128: G = G::from_u64(9); let __v_129: G = G::from_u64(106); let __v_130: G = G::from_u64(133); let __v_131: G = G::from_u64(174); let __v_132: G = G::from_u64(187); let __v_133: G = G::from_u64(114); let __v_134: G = G::from_u64(243); let __v_135: G = G::from_u64(110); let __v_136: G = G::from_u64(60); let __v_137: G = G::from_u64(58); let __v_138: G = G::from_u64(245); let __v_139: G = G::from_u64(79); let __v_140: G = G::from_u64(165); let __v_141: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_141, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_126, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_125, __v_141, __v_141, __v_141, __v_92, __v_141, __v_141, __v_141, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __v_152: G = __r_arr[10]; let __v_153: G = __r_arr[11]; let __v_154: G = __r_arr[12]; let __v_155: G = __r_arr[13]; let __v_156: G = __r_arr[14]; let __v_157: G = __r_arr[15]; let __v_158: G = __r_arr[16]; let __v_159: G = __r_arr[17]; let __v_160: G = __r_arr[18]; let __v_161: G = __r_arr[19]; let __v_162: G = __r_arr[20]; let __v_163: G = __r_arr[21]; let __v_164: G = __r_arr[22]; let __v_165: G = __r_arr[23]; let __v_166: G = __r_arr[24]; let __v_167: G = __r_arr[25]; let __v_168: G = __r_arr[26]; let __v_169: G = __r_arr[27]; let __v_170: G = __r_arr[28]; let __v_171: G = __r_arr[29]; let __v_172: G = __r_arr[30]; let __v_173: G = __r_arr[31]; let __v_174: G = G::from_u64(1); let __v_175: G = { let __values: [G; 3] = [__v_174, __v_174, __v_174]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_176: G = __v_2 + __v_174; let __v_177: G = { let __values: [G; 32] = [__v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_178]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_80: usize = 24; const IN_80: usize = 24; const OUT_80: usize = 16; -fn aiur_fn_80(inp: [G; IN_80], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); let __v_32: G = (__v_28 - __v_31); let __v_33: G = (__v_30 * __v_32); let __v_34: G = (__v_28 * __v_33); let __v_35: G = G::from_u64(0); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_36: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_24)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_24, record) }; let __v_37: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_25)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_25, record) }; let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_26)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_26, record) }; let __v_39: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_27)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_27, record) }; let __u32_sum: u128 = (u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24))) + u128::from(((((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8)) | (__v_36.as_canonical_u64() << 16)) | (__v_37.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); let __v_41: G = G::from_u8(__u32_bytes[1]); let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_4), (&__v_40)) } else { aiur::execute::bytes2_xor_split4_value(__v_4, __v_40, record) }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_5), (&__v_41)) } else { aiur::execute::bytes2_xor_split4_value(__v_5, __v_41, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_6), (&__v_42)) } else { aiur::execute::bytes2_xor_split4_value(__v_6, __v_42, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_7), (&__v_43)) } else { aiur::execute::bytes2_xor_split4_value(__v_7, __v_43, record) }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); let __v_55: G = (__v_50 + __v_53); let __v_56: G = (__v_52 + __v_47); let __v_57: G = (__v_46 + __v_49); let __u32_sum: u128 = ((u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24))) + u128::from(((((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8)) | (__v_56.as_canonical_u64() << 16)) | (__v_57.as_canonical_u64() << 24)))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_58: G = G::from_u8(__u32_bytes[0]); let __v_59: G = G::from_u8(__u32_bytes[1]); let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_63: G = (__v_62 - __v_29); let __v_64: G = (__v_62 - __v_31); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 * __v_65); if (__v_66 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_67: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_38), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_38, __v_58, record) }; let __v_68: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_39), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_39, __v_59, record) }; let __v_69: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_36), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_36, __v_60, record) }; let __v_70: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_37), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_37, __v_61, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_71: G = G::from_u8(__u32_bytes[0]); let __v_72: G = G::from_u8(__u32_bytes[1]); let __v_73: G = G::from_u8(__u32_bytes[2]); let __v_74: G = G::from_u8(__u32_bytes[3]); let __v_75: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_76: G = (__v_75 * __v_75); if (__v_76 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_54), (&__v_71)) } else { aiur::execute::bytes2_xor_split7_value(__v_54, __v_71, record) }; let __v_77: G = __b2_out.0; let __v_78: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_55), (&__v_72)) } else { aiur::execute::bytes2_xor_split7_value(__v_55, __v_72, record) }; let __v_79: G = __b2_out.0; let __v_80: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_56), (&__v_73)) } else { aiur::execute::bytes2_xor_split7_value(__v_56, __v_73, record) }; let __v_81: G = __b2_out.0; let __v_82: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_57), (&__v_74)) } else { aiur::execute::bytes2_xor_split7_value(__v_57, __v_74, record) }; let __v_83: G = __b2_out.0; let __v_84: G = __b2_out.1; let __v_85: G = (__v_77 + __v_80); let __v_86: G = (__v_79 + __v_82); let __v_87: G = (__v_81 + __v_84); let __v_88: G = (__v_83 + __v_78); let __ret: [G; OUT_80] = [__v_58, __v_59, __v_60, __v_61, __v_85, __v_86, __v_87, __v_88, __v_71, __v_72, __v_73, __v_74, __v_68, __v_69, __v_70, __v_67]; record.function_queries[80].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_80(inp: [G; IN_80], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __u32_sum: u128 = (u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24))) + u128::from((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); let __v_25: G = G::from_u8(__u32_bytes[1]); let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_29: G = G::from_u64(1); let __v_30: G = __v_28 - __v_29; let __v_31: G = G::from_u64(2); let __v_32: G = __v_28 - __v_31; let __v_33: G = __v_30 * __v_32; let __v_34: G = __v_28 * __v_33; let __v_35: G = G::from_u64(0); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_36: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_12, &__v_24) } else { aiur::execute::bytes2_xor_value(__v_12, __v_24, record) }; let __v_37: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_13, &__v_25) } else { aiur::execute::bytes2_xor_value(__v_13, __v_25, record) }; let __v_38: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_14, &__v_26) } else { aiur::execute::bytes2_xor_value(__v_14, __v_26, record) }; let __v_39: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_15, &__v_27) } else { aiur::execute::bytes2_xor_value(__v_15, __v_27, record) }; let __u32_sum: u128 = u128::from((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)) + u128::from((((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8)) | (__v_36.as_canonical_u64() << 16)) | (__v_37.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); let __v_41: G = G::from_u8(__u32_bytes[1]); let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_45: G = __v_44 * __v_44; if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_4, &__v_40) } else { aiur::execute::bytes2_xor_split4_value(__v_4, __v_40, record) }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_5, &__v_41) } else { aiur::execute::bytes2_xor_split4_value(__v_5, __v_41, record) }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_6, &__v_42) } else { aiur::execute::bytes2_xor_split4_value(__v_6, __v_42, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_7, &__v_43) } else { aiur::execute::bytes2_xor_split4_value(__v_7, __v_43, record) }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = __v_48 + __v_51; let __v_55: G = __v_50 + __v_53; let __v_56: G = __v_52 + __v_47; let __v_57: G = __v_46 + __v_49; let __u32_sum: u128 = (u128::from((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24)) + u128::from((((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8)) | (__v_56.as_canonical_u64() << 16)) | (__v_57.as_canonical_u64() << 24))) + u128::from((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_58: G = G::from_u8(__u32_bytes[0]); let __v_59: G = G::from_u8(__u32_bytes[1]); let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_63: G = __v_62 - __v_29; let __v_64: G = __v_62 - __v_31; let __v_65: G = __v_63 * __v_64; let __v_66: G = __v_62 * __v_65; if (__v_66 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_67: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_38, &__v_58) } else { aiur::execute::bytes2_xor_value(__v_38, __v_58, record) }; let __v_68: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_39, &__v_59) } else { aiur::execute::bytes2_xor_value(__v_39, __v_59, record) }; let __v_69: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_36, &__v_60) } else { aiur::execute::bytes2_xor_value(__v_36, __v_60, record) }; let __v_70: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_37, &__v_61) } else { aiur::execute::bytes2_xor_value(__v_37, __v_61, record) }; let __u32_sum: u128 = u128::from((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24)) + u128::from((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_71: G = G::from_u8(__u32_bytes[0]); let __v_72: G = G::from_u8(__u32_bytes[1]); let __v_73: G = G::from_u8(__u32_bytes[2]); let __v_74: G = G::from_u8(__u32_bytes[3]); let __v_75: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_76: G = __v_75 * __v_75; if (__v_76 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_54, &__v_71) } else { aiur::execute::bytes2_xor_split7_value(__v_54, __v_71, record) }; let __v_77: G = __b2_out.0; let __v_78: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_55, &__v_72) } else { aiur::execute::bytes2_xor_split7_value(__v_55, __v_72, record) }; let __v_79: G = __b2_out.0; let __v_80: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_56, &__v_73) } else { aiur::execute::bytes2_xor_split7_value(__v_56, __v_73, record) }; let __v_81: G = __b2_out.0; let __v_82: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_57, &__v_74) } else { aiur::execute::bytes2_xor_split7_value(__v_57, __v_74, record) }; let __v_83: G = __b2_out.0; let __v_84: G = __b2_out.1; let __v_85: G = __v_77 + __v_80; let __v_86: G = __v_79 + __v_82; let __v_87: G = __v_81 + __v_84; let __v_88: G = __v_83 + __v_78; let __ret: [G; OUT_80] = [__v_58, __v_59, __v_60, __v_61, __v_85, __v_86, __v_87, __v_88, __v_71, __v_72, __v_73, __v_74, __v_68, __v_69, __v_70, __v_67]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_81: usize = 128; const IN_81: usize = 128; const OUT_81: usize = 128; -fn aiur_fn_81(inp: [G; IN_81], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __u32_sum: u128 = ((u128::from(((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24))) + u128::from(((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24)))) + u128::from(((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); let __v_136: G = (__v_132 - __v_135); let __v_137: G = (__v_134 * __v_136); let __v_138: G = (__v_132 * __v_137); let __v_139: G = G::from_u64(0); if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_48), (&__v_128)) } else { aiur::execute::bytes2_xor_value(__v_48, __v_128, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __u32_sum: u128 = (u128::from(((((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8)) | (__v_34.as_canonical_u64() << 16)) | (__v_35.as_canonical_u64() << 24))) + u128::from(((((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8)) | (__v_140.as_canonical_u64() << 16)) | (__v_141.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); let __v_145: G = G::from_u8(__u32_bytes[1]); let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_16), (&__v_144)) } else { aiur::execute::bytes2_xor_split4_value(__v_16, __v_144, record) }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); let __v_159: G = (__v_154 + __v_157); let __v_160: G = (__v_156 + __v_151); let __v_161: G = (__v_150 + __v_153); let __u32_sum: u128 = ((u128::from(((((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8)) | (__v_130.as_canonical_u64() << 16)) | (__v_131.as_canonical_u64() << 24))) + u128::from(((((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8)) | (__v_160.as_canonical_u64() << 16)) | (__v_161.as_canonical_u64() << 24)))) + u128::from(((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_71.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_162: G = G::from_u8(__u32_bytes[0]); let __v_163: G = G::from_u8(__u32_bytes[1]); let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_167: G = (__v_166 - __v_133); let __v_168: G = (__v_166 - __v_135); let __v_169: G = (__v_167 * __v_168); let __v_170: G = (__v_166 * __v_169); if (__v_170 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_171: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_162)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_162, record) }; let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_140), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_140, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __u32_sum: u128 = (u128::from(((((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8)) | (__v_146.as_canonical_u64() << 16)) | (__v_147.as_canonical_u64() << 24))) + u128::from(((((__v_172.as_canonical_u64() << 0) | (__v_173.as_canonical_u64() << 8)) | (__v_174.as_canonical_u64() << 16)) | (__v_171.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_175: G = G::from_u8(__u32_bytes[0]); let __v_176: G = G::from_u8(__u32_bytes[1]); let __v_177: G = G::from_u8(__u32_bytes[2]); let __v_178: G = G::from_u8(__u32_bytes[3]); let __v_179: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_175; let __vj = __v_176; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_177; let __vj = __v_178; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_180: G = (__v_179 * __v_179); if (__v_180 != __v_179) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_179.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_158), (&__v_175)) } else { aiur::execute::bytes2_xor_split7_value(__v_158, __v_175, record) }; let __v_181: G = __b2_out.0; let __v_182: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_183: G = __b2_out.0; let __v_184: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; let __v_189: G = (__v_181 + __v_184); let __v_190: G = (__v_183 + __v_186); let __v_191: G = (__v_185 + __v_188); let __v_192: G = (__v_187 + __v_182); let __u32_sum: u128 = ((u128::from(((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24))) + u128::from(((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24)))) + u128::from(((((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8)) | (__v_74.as_canonical_u64() << 16)) | (__v_75.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_193: G = G::from_u8(__u32_bytes[0]); let __v_194: G = G::from_u8(__u32_bytes[1]); let __v_195: G = G::from_u8(__u32_bytes[2]); let __v_196: G = G::from_u8(__u32_bytes[3]); let __v_197: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_193; let __vj = __v_194; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_195; let __vj = __v_196; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_198: G = (__v_197 - __v_133); let __v_199: G = (__v_197 - __v_135); let __v_200: G = (__v_198 * __v_199); let __v_201: G = (__v_197 * __v_200); if (__v_201 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_202: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_193)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_193, record) }; let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __u32_sum: u128 = (u128::from(((((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8)) | (__v_38.as_canonical_u64() << 16)) | (__v_39.as_canonical_u64() << 24))) + u128::from(((((__v_204.as_canonical_u64() << 0) | (__v_205.as_canonical_u64() << 8)) | (__v_202.as_canonical_u64() << 16)) | (__v_203.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_206: G = G::from_u8(__u32_bytes[0]); let __v_207: G = G::from_u8(__u32_bytes[1]); let __v_208: G = G::from_u8(__u32_bytes[2]); let __v_209: G = G::from_u8(__u32_bytes[3]); let __v_210: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_206; let __vj = __v_207; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_208; let __vj = __v_209; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_211: G = (__v_210 * __v_210); if (__v_211 != __v_210) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_210.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_206)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_206, record) }; let __v_212: G = __b2_out.0; let __v_213: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_214: G = __b2_out.0; let __v_215: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_216: G = __b2_out.0; let __v_217: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; let __v_220: G = (__v_214 + __v_217); let __v_221: G = (__v_216 + __v_219); let __v_222: G = (__v_218 + __v_213); let __v_223: G = (__v_212 + __v_215); let __u32_sum: u128 = ((u128::from(((((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8)) | (__v_195.as_canonical_u64() << 16)) | (__v_196.as_canonical_u64() << 24))) + u128::from(((((__v_220.as_canonical_u64() << 0) | (__v_221.as_canonical_u64() << 8)) | (__v_222.as_canonical_u64() << 16)) | (__v_223.as_canonical_u64() << 24)))) + u128::from(((((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8)) | (__v_78.as_canonical_u64() << 16)) | (__v_79.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_224: G = G::from_u8(__u32_bytes[0]); let __v_225: G = G::from_u8(__u32_bytes[1]); let __v_226: G = G::from_u8(__u32_bytes[2]); let __v_227: G = G::from_u8(__u32_bytes[3]); let __v_228: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_224; let __vj = __v_225; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_226; let __vj = __v_227; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_229: G = (__v_228 - __v_133); let __v_230: G = (__v_228 - __v_135); let __v_231: G = (__v_229 * __v_230); let __v_232: G = (__v_228 * __v_231); if (__v_232 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_233: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_224)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_224, record) }; let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_202), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_202, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __u32_sum: u128 = (u128::from(((((__v_206.as_canonical_u64() << 0) | (__v_207.as_canonical_u64() << 8)) | (__v_208.as_canonical_u64() << 16)) | (__v_209.as_canonical_u64() << 24))) + u128::from(((((__v_234.as_canonical_u64() << 0) | (__v_235.as_canonical_u64() << 8)) | (__v_236.as_canonical_u64() << 16)) | (__v_233.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_237: G = G::from_u8(__u32_bytes[0]); let __v_238: G = G::from_u8(__u32_bytes[1]); let __v_239: G = G::from_u8(__u32_bytes[2]); let __v_240: G = G::from_u8(__u32_bytes[3]); let __v_241: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_239; let __vj = __v_240; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_242: G = (__v_241 * __v_241); if (__v_242 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_220), (&__v_237)) } else { aiur::execute::bytes2_xor_split7_value(__v_220, __v_237, record) }; let __v_243: G = __b2_out.0; let __v_244: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_245: G = __b2_out.0; let __v_246: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_247: G = __b2_out.0; let __v_248: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_249: G = __b2_out.0; let __v_250: G = __b2_out.1; let __v_251: G = (__v_243 + __v_246); let __v_252: G = (__v_245 + __v_248); let __v_253: G = (__v_247 + __v_250); let __v_254: G = (__v_249 + __v_244); let __u32_sum: u128 = ((u128::from(((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24))) + u128::from(((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24)))) + u128::from(((((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8)) | (__v_82.as_canonical_u64() << 16)) | (__v_83.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_255: G = G::from_u8(__u32_bytes[0]); let __v_256: G = G::from_u8(__u32_bytes[1]); let __v_257: G = G::from_u8(__u32_bytes[2]); let __v_258: G = G::from_u8(__u32_bytes[3]); let __v_259: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_255; let __vj = __v_256; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_257; let __vj = __v_258; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_260: G = (__v_259 - __v_133); let __v_261: G = (__v_259 - __v_135); let __v_262: G = (__v_260 * __v_261); let __v_263: G = (__v_259 * __v_262); if (__v_263 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_263.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_264: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_255)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_255, record) }; let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __u32_sum: u128 = (u128::from(((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24))) + u128::from(((((__v_266.as_canonical_u64() << 0) | (__v_267.as_canonical_u64() << 8)) | (__v_264.as_canonical_u64() << 16)) | (__v_265.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_268: G = G::from_u8(__u32_bytes[0]); let __v_269: G = G::from_u8(__u32_bytes[1]); let __v_270: G = G::from_u8(__u32_bytes[2]); let __v_271: G = G::from_u8(__u32_bytes[3]); let __v_272: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_273: G = (__v_272 * __v_272); if (__v_273 != __v_272) { return Err(ExecError::AssertEqMismatch { lhs: __v_273.as_canonical_u64(), rhs: __v_272.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_268)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_268, record) }; let __v_274: G = __b2_out.0; let __v_275: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_276: G = __b2_out.0; let __v_277: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_278: G = __b2_out.0; let __v_279: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_280: G = __b2_out.0; let __v_281: G = __b2_out.1; let __v_282: G = (__v_276 + __v_279); let __v_283: G = (__v_278 + __v_281); let __v_284: G = (__v_280 + __v_275); let __v_285: G = (__v_274 + __v_277); let __u32_sum: u128 = ((u128::from(((((__v_255.as_canonical_u64() << 0) | (__v_256.as_canonical_u64() << 8)) | (__v_257.as_canonical_u64() << 16)) | (__v_258.as_canonical_u64() << 24))) + u128::from(((((__v_282.as_canonical_u64() << 0) | (__v_283.as_canonical_u64() << 8)) | (__v_284.as_canonical_u64() << 16)) | (__v_285.as_canonical_u64() << 24)))) + u128::from(((((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8)) | (__v_86.as_canonical_u64() << 16)) | (__v_87.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_286: G = G::from_u8(__u32_bytes[0]); let __v_287: G = G::from_u8(__u32_bytes[1]); let __v_288: G = G::from_u8(__u32_bytes[2]); let __v_289: G = G::from_u8(__u32_bytes[3]); let __v_290: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_286; let __vj = __v_287; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_288; let __vj = __v_289; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_291: G = (__v_290 - __v_133); let __v_292: G = (__v_290 - __v_135); let __v_293: G = (__v_291 * __v_292); let __v_294: G = (__v_290 * __v_293); if (__v_294 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_294.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_295: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_286)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_286, record) }; let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_264), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_264, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __u32_sum: u128 = (u128::from(((((__v_268.as_canonical_u64() << 0) | (__v_269.as_canonical_u64() << 8)) | (__v_270.as_canonical_u64() << 16)) | (__v_271.as_canonical_u64() << 24))) + u128::from(((((__v_296.as_canonical_u64() << 0) | (__v_297.as_canonical_u64() << 8)) | (__v_298.as_canonical_u64() << 16)) | (__v_295.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_299: G = G::from_u8(__u32_bytes[0]); let __v_300: G = G::from_u8(__u32_bytes[1]); let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_304: G = (__v_303 * __v_303); if (__v_304 != __v_303) { return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_303.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_282), (&__v_299)) } else { aiur::execute::bytes2_xor_split7_value(__v_282, __v_299, record) }; let __v_305: G = __b2_out.0; let __v_306: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_307: G = __b2_out.0; let __v_308: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_309: G = __b2_out.0; let __v_310: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_311: G = __b2_out.0; let __v_312: G = __b2_out.1; let __v_313: G = (__v_305 + __v_308); let __v_314: G = (__v_307 + __v_310); let __v_315: G = (__v_309 + __v_312); let __v_316: G = (__v_311 + __v_306); let __u32_sum: u128 = ((u128::from(((((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8)) | (__v_14.as_canonical_u64() << 16)) | (__v_15.as_canonical_u64() << 24))) + u128::from(((((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8)) | (__v_30.as_canonical_u64() << 16)) | (__v_31.as_canonical_u64() << 24)))) + u128::from(((((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8)) | (__v_90.as_canonical_u64() << 16)) | (__v_91.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_317: G = G::from_u8(__u32_bytes[0]); let __v_318: G = G::from_u8(__u32_bytes[1]); let __v_319: G = G::from_u8(__u32_bytes[2]); let __v_320: G = G::from_u8(__u32_bytes[3]); let __v_321: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_319; let __vj = __v_320; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_322: G = (__v_321 - __v_133); let __v_323: G = (__v_321 - __v_135); let __v_324: G = (__v_322 * __v_323); let __v_325: G = (__v_321 * __v_324); if (__v_325 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_325.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_326: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_317)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_317, record) }; let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __u32_sum: u128 = (u128::from(((((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8)) | (__v_46.as_canonical_u64() << 16)) | (__v_47.as_canonical_u64() << 24))) + u128::from(((((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8)) | (__v_326.as_canonical_u64() << 16)) | (__v_327.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_330: G = G::from_u8(__u32_bytes[0]); let __v_331: G = G::from_u8(__u32_bytes[1]); let __v_332: G = G::from_u8(__u32_bytes[2]); let __v_333: G = G::from_u8(__u32_bytes[3]); let __v_334: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_330; let __vj = __v_331; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_335: G = (__v_334 * __v_334); if (__v_335 != __v_334) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_334.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_330)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_330, record) }; let __v_336: G = __b2_out.0; let __v_337: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_338: G = __b2_out.0; let __v_339: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_340: G = __b2_out.0; let __v_341: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_342: G = __b2_out.0; let __v_343: G = __b2_out.1; let __v_344: G = (__v_338 + __v_341); let __v_345: G = (__v_340 + __v_343); let __v_346: G = (__v_342 + __v_337); let __v_347: G = (__v_336 + __v_339); let __u32_sum: u128 = ((u128::from(((((__v_317.as_canonical_u64() << 0) | (__v_318.as_canonical_u64() << 8)) | (__v_319.as_canonical_u64() << 16)) | (__v_320.as_canonical_u64() << 24))) + u128::from(((((__v_344.as_canonical_u64() << 0) | (__v_345.as_canonical_u64() << 8)) | (__v_346.as_canonical_u64() << 16)) | (__v_347.as_canonical_u64() << 24)))) + u128::from(((((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8)) | (__v_94.as_canonical_u64() << 16)) | (__v_95.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); let __v_349: G = G::from_u8(__u32_bytes[1]); let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_353: G = (__v_352 - __v_133); let __v_354: G = (__v_352 - __v_135); let __v_355: G = (__v_353 * __v_354); let __v_356: G = (__v_352 * __v_355); if (__v_356 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_357: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_348)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_348, record) }; let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_326), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_326, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __u32_sum: u128 = (u128::from(((((__v_330.as_canonical_u64() << 0) | (__v_331.as_canonical_u64() << 8)) | (__v_332.as_canonical_u64() << 16)) | (__v_333.as_canonical_u64() << 24))) + u128::from(((((__v_358.as_canonical_u64() << 0) | (__v_359.as_canonical_u64() << 8)) | (__v_360.as_canonical_u64() << 16)) | (__v_357.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_361: G = G::from_u8(__u32_bytes[0]); let __v_362: G = G::from_u8(__u32_bytes[1]); let __v_363: G = G::from_u8(__u32_bytes[2]); let __v_364: G = G::from_u8(__u32_bytes[3]); let __v_365: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_361; let __vj = __v_362; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_363; let __vj = __v_364; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_366: G = (__v_365 * __v_365); if (__v_366 != __v_365) { return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_365.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_344), (&__v_361)) } else { aiur::execute::bytes2_xor_split7_value(__v_344, __v_361, record) }; let __v_367: G = __b2_out.0; let __v_368: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_369: G = __b2_out.0; let __v_370: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_371: G = __b2_out.0; let __v_372: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_373: G = __b2_out.0; let __v_374: G = __b2_out.1; let __v_375: G = (__v_367 + __v_370); let __v_376: G = (__v_369 + __v_372); let __v_377: G = (__v_371 + __v_374); let __v_378: G = (__v_373 + __v_368); let __u32_sum: u128 = ((u128::from(((((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8)) | (__v_164.as_canonical_u64() << 16)) | (__v_165.as_canonical_u64() << 24))) + u128::from(((((__v_251.as_canonical_u64() << 0) | (__v_252.as_canonical_u64() << 8)) | (__v_253.as_canonical_u64() << 16)) | (__v_254.as_canonical_u64() << 24)))) + u128::from(((((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8)) | (__v_98.as_canonical_u64() << 16)) | (__v_99.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_379: G = G::from_u8(__u32_bytes[0]); let __v_380: G = G::from_u8(__u32_bytes[1]); let __v_381: G = G::from_u8(__u32_bytes[2]); let __v_382: G = G::from_u8(__u32_bytes[3]); let __v_383: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_379; let __vj = __v_380; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_381; let __vj = __v_382; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_384: G = (__v_383 - __v_133); let __v_385: G = (__v_383 - __v_135); let __v_386: G = (__v_384 * __v_385); let __v_387: G = (__v_383 * __v_386); if (__v_387 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_388: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_379)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_379, record) }; let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_357), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_357, __v_382, record) }; let __u32_sum: u128 = (u128::from(((((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8)) | (__v_301.as_canonical_u64() << 16)) | (__v_302.as_canonical_u64() << 24))) + u128::from(((((__v_390.as_canonical_u64() << 0) | (__v_391.as_canonical_u64() << 8)) | (__v_388.as_canonical_u64() << 16)) | (__v_389.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_392: G = G::from_u8(__u32_bytes[0]); let __v_393: G = G::from_u8(__u32_bytes[1]); let __v_394: G = G::from_u8(__u32_bytes[2]); let __v_395: G = G::from_u8(__u32_bytes[3]); let __v_396: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_392; let __vj = __v_393; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_394; let __vj = __v_395; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_397: G = (__v_396 * __v_396); if (__v_397 != __v_396) { return Err(ExecError::AssertEqMismatch { lhs: __v_397.as_canonical_u64(), rhs: __v_396.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_251), (&__v_392)) } else { aiur::execute::bytes2_xor_split4_value(__v_251, __v_392, record) }; let __v_398: G = __b2_out.0; let __v_399: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_400: G = __b2_out.0; let __v_401: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_402: G = __b2_out.0; let __v_403: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_404: G = __b2_out.0; let __v_405: G = __b2_out.1; let __v_406: G = (__v_400 + __v_403); let __v_407: G = (__v_402 + __v_405); let __v_408: G = (__v_404 + __v_399); let __v_409: G = (__v_398 + __v_401); let __u32_sum: u128 = ((u128::from(((((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8)) | (__v_381.as_canonical_u64() << 16)) | (__v_382.as_canonical_u64() << 24))) + u128::from(((((__v_406.as_canonical_u64() << 0) | (__v_407.as_canonical_u64() << 8)) | (__v_408.as_canonical_u64() << 16)) | (__v_409.as_canonical_u64() << 24)))) + u128::from(((((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8)) | (__v_102.as_canonical_u64() << 16)) | (__v_103.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_410: G = G::from_u8(__u32_bytes[0]); let __v_411: G = G::from_u8(__u32_bytes[1]); let __v_412: G = G::from_u8(__u32_bytes[2]); let __v_413: G = G::from_u8(__u32_bytes[3]); let __v_414: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_410; let __vj = __v_411; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_412; let __vj = __v_413; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_415: G = (__v_414 - __v_133); let __v_416: G = (__v_414 - __v_135); let __v_417: G = (__v_415 * __v_416); let __v_418: G = (__v_414 * __v_417); if (__v_418 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_418.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_419: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_410)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_410, record) }; let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_388), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_388, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __u32_sum: u128 = (u128::from(((((__v_392.as_canonical_u64() << 0) | (__v_393.as_canonical_u64() << 8)) | (__v_394.as_canonical_u64() << 16)) | (__v_395.as_canonical_u64() << 24))) + u128::from(((((__v_420.as_canonical_u64() << 0) | (__v_421.as_canonical_u64() << 8)) | (__v_422.as_canonical_u64() << 16)) | (__v_419.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_423: G = G::from_u8(__u32_bytes[0]); let __v_424: G = G::from_u8(__u32_bytes[1]); let __v_425: G = G::from_u8(__u32_bytes[2]); let __v_426: G = G::from_u8(__u32_bytes[3]); let __v_427: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_423; let __vj = __v_424; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_425; let __vj = __v_426; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_428: G = (__v_427 * __v_427); if (__v_428 != __v_427) { return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_427.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_406), (&__v_423)) } else { aiur::execute::bytes2_xor_split7_value(__v_406, __v_423, record) }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_431: G = __b2_out.0; let __v_432: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_433: G = __b2_out.0; let __v_434: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_435: G = __b2_out.0; let __v_436: G = __b2_out.1; let __v_437: G = (__v_429 + __v_432); let __v_438: G = (__v_431 + __v_434); let __v_439: G = (__v_433 + __v_436); let __v_440: G = (__v_435 + __v_430); let __u32_sum: u128 = ((u128::from(((((__v_224.as_canonical_u64() << 0) | (__v_225.as_canonical_u64() << 8)) | (__v_226.as_canonical_u64() << 16)) | (__v_227.as_canonical_u64() << 24))) + u128::from(((((__v_313.as_canonical_u64() << 0) | (__v_314.as_canonical_u64() << 8)) | (__v_315.as_canonical_u64() << 16)) | (__v_316.as_canonical_u64() << 24)))) + u128::from(((((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8)) | (__v_106.as_canonical_u64() << 16)) | (__v_107.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_441: G = G::from_u8(__u32_bytes[0]); let __v_442: G = G::from_u8(__u32_bytes[1]); let __v_443: G = G::from_u8(__u32_bytes[2]); let __v_444: G = G::from_u8(__u32_bytes[3]); let __v_445: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_441; let __vj = __v_442; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_443; let __vj = __v_444; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_446: G = (__v_445 - __v_133); let __v_447: G = (__v_445 - __v_135); let __v_448: G = (__v_446 * __v_447); let __v_449: G = (__v_445 * __v_448); if (__v_449 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_449.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_450: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_441)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_441, record) }; let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_171), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_171, __v_444, record) }; let __u32_sum: u128 = (u128::from(((((__v_361.as_canonical_u64() << 0) | (__v_362.as_canonical_u64() << 8)) | (__v_363.as_canonical_u64() << 16)) | (__v_364.as_canonical_u64() << 24))) + u128::from(((((__v_452.as_canonical_u64() << 0) | (__v_453.as_canonical_u64() << 8)) | (__v_450.as_canonical_u64() << 16)) | (__v_451.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_454: G = G::from_u8(__u32_bytes[0]); let __v_455: G = G::from_u8(__u32_bytes[1]); let __v_456: G = G::from_u8(__u32_bytes[2]); let __v_457: G = G::from_u8(__u32_bytes[3]); let __v_458: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_454; let __vj = __v_455; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_456; let __vj = __v_457; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_459: G = (__v_458 * __v_458); if (__v_459 != __v_458) { return Err(ExecError::AssertEqMismatch { lhs: __v_459.as_canonical_u64(), rhs: __v_458.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_313), (&__v_454)) } else { aiur::execute::bytes2_xor_split4_value(__v_313, __v_454, record) }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_464: G = __b2_out.0; let __v_465: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_466: G = __b2_out.0; let __v_467: G = __b2_out.1; let __v_468: G = (__v_462 + __v_465); let __v_469: G = (__v_464 + __v_467); let __v_470: G = (__v_466 + __v_461); let __v_471: G = (__v_460 + __v_463); let __u32_sum: u128 = ((u128::from(((((__v_441.as_canonical_u64() << 0) | (__v_442.as_canonical_u64() << 8)) | (__v_443.as_canonical_u64() << 16)) | (__v_444.as_canonical_u64() << 24))) + u128::from(((((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8)) | (__v_470.as_canonical_u64() << 16)) | (__v_471.as_canonical_u64() << 24)))) + u128::from(((((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8)) | (__v_110.as_canonical_u64() << 16)) | (__v_111.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_472: G = G::from_u8(__u32_bytes[0]); let __v_473: G = G::from_u8(__u32_bytes[1]); let __v_474: G = G::from_u8(__u32_bytes[2]); let __v_475: G = G::from_u8(__u32_bytes[3]); let __v_476: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_472; let __vj = __v_473; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_474; let __vj = __v_475; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_477: G = (__v_476 - __v_133); let __v_478: G = (__v_476 - __v_135); let __v_479: G = (__v_477 * __v_478); let __v_480: G = (__v_476 * __v_479); if (__v_480 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_481: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_472)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_472, record) }; let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_450), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_450, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __u32_sum: u128 = (u128::from(((((__v_454.as_canonical_u64() << 0) | (__v_455.as_canonical_u64() << 8)) | (__v_456.as_canonical_u64() << 16)) | (__v_457.as_canonical_u64() << 24))) + u128::from(((((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8)) | (__v_484.as_canonical_u64() << 16)) | (__v_481.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); let __v_486: G = G::from_u8(__u32_bytes[1]); let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_468), (&__v_485)) } else { aiur::execute::bytes2_xor_split7_value(__v_468, __v_485, record) }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_491 + __v_494); let __v_500: G = (__v_493 + __v_496); let __v_501: G = (__v_495 + __v_498); let __v_502: G = (__v_497 + __v_492); let __u32_sum: u128 = ((u128::from(((((__v_286.as_canonical_u64() << 0) | (__v_287.as_canonical_u64() << 8)) | (__v_288.as_canonical_u64() << 16)) | (__v_289.as_canonical_u64() << 24))) + u128::from(((((__v_375.as_canonical_u64() << 0) | (__v_376.as_canonical_u64() << 8)) | (__v_377.as_canonical_u64() << 16)) | (__v_378.as_canonical_u64() << 24)))) + u128::from(((((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8)) | (__v_114.as_canonical_u64() << 16)) | (__v_115.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_503: G = G::from_u8(__u32_bytes[0]); let __v_504: G = G::from_u8(__u32_bytes[1]); let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_508: G = (__v_507 - __v_133); let __v_509: G = (__v_507 - __v_135); let __v_510: G = (__v_508 * __v_509); let __v_511: G = (__v_507 * __v_510); if (__v_511 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_512: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_503)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_503, record) }; let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_233), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_233, __v_506, record) }; let __u32_sum: u128 = (u128::from(((((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8)) | (__v_177.as_canonical_u64() << 16)) | (__v_178.as_canonical_u64() << 24))) + u128::from(((((__v_514.as_canonical_u64() << 0) | (__v_515.as_canonical_u64() << 8)) | (__v_512.as_canonical_u64() << 16)) | (__v_513.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_516: G = G::from_u8(__u32_bytes[0]); let __v_517: G = G::from_u8(__u32_bytes[1]); let __v_518: G = G::from_u8(__u32_bytes[2]); let __v_519: G = G::from_u8(__u32_bytes[3]); let __v_520: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_516; let __vj = __v_517; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_521: G = (__v_520 * __v_520); if (__v_521 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_375), (&__v_516)) } else { aiur::execute::bytes2_xor_split4_value(__v_375, __v_516, record) }; let __v_522: G = __b2_out.0; let __v_523: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; let __v_530: G = (__v_524 + __v_527); let __v_531: G = (__v_526 + __v_529); let __v_532: G = (__v_528 + __v_523); let __v_533: G = (__v_522 + __v_525); let __u32_sum: u128 = ((u128::from(((((__v_503.as_canonical_u64() << 0) | (__v_504.as_canonical_u64() << 8)) | (__v_505.as_canonical_u64() << 16)) | (__v_506.as_canonical_u64() << 24))) + u128::from(((((__v_530.as_canonical_u64() << 0) | (__v_531.as_canonical_u64() << 8)) | (__v_532.as_canonical_u64() << 16)) | (__v_533.as_canonical_u64() << 24)))) + u128::from(((((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8)) | (__v_118.as_canonical_u64() << 16)) | (__v_119.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_534: G = G::from_u8(__u32_bytes[0]); let __v_535: G = G::from_u8(__u32_bytes[1]); let __v_536: G = G::from_u8(__u32_bytes[2]); let __v_537: G = G::from_u8(__u32_bytes[3]); let __v_538: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_534; let __vj = __v_535; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_539: G = (__v_538 - __v_133); let __v_540: G = (__v_538 - __v_135); let __v_541: G = (__v_539 * __v_540); let __v_542: G = (__v_538 * __v_541); if (__v_542 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_542.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_543: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_534)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_534, record) }; let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_512), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_512, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __u32_sum: u128 = (u128::from(((((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8)) | (__v_518.as_canonical_u64() << 16)) | (__v_519.as_canonical_u64() << 24))) + u128::from(((((__v_544.as_canonical_u64() << 0) | (__v_545.as_canonical_u64() << 8)) | (__v_546.as_canonical_u64() << 16)) | (__v_543.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_547: G = G::from_u8(__u32_bytes[0]); let __v_548: G = G::from_u8(__u32_bytes[1]); let __v_549: G = G::from_u8(__u32_bytes[2]); let __v_550: G = G::from_u8(__u32_bytes[3]); let __v_551: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_547; let __vj = __v_548; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_549; let __vj = __v_550; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_552: G = (__v_551 * __v_551); if (__v_552 != __v_551) { return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_551.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_530), (&__v_547)) } else { aiur::execute::bytes2_xor_split7_value(__v_530, __v_547, record) }; let __v_553: G = __b2_out.0; let __v_554: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_555: G = __b2_out.0; let __v_556: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_557: G = __b2_out.0; let __v_558: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; let __v_561: G = (__v_553 + __v_556); let __v_562: G = (__v_555 + __v_558); let __v_563: G = (__v_557 + __v_560); let __v_564: G = (__v_559 + __v_554); let __u32_sum: u128 = ((u128::from(((((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8)) | (__v_350.as_canonical_u64() << 16)) | (__v_351.as_canonical_u64() << 24))) + u128::from(((((__v_189.as_canonical_u64() << 0) | (__v_190.as_canonical_u64() << 8)) | (__v_191.as_canonical_u64() << 16)) | (__v_192.as_canonical_u64() << 24)))) + u128::from(((((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8)) | (__v_122.as_canonical_u64() << 16)) | (__v_123.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_565: G = G::from_u8(__u32_bytes[0]); let __v_566: G = G::from_u8(__u32_bytes[1]); let __v_567: G = G::from_u8(__u32_bytes[2]); let __v_568: G = G::from_u8(__u32_bytes[3]); let __v_569: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_565; let __vj = __v_566; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_567; let __vj = __v_568; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_570: G = (__v_569 - __v_133); let __v_571: G = (__v_569 - __v_135); let __v_572: G = (__v_570 * __v_571); let __v_573: G = (__v_569 * __v_572); if (__v_573 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_574: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_565)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_565, record) }; let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_295), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_295, __v_568, record) }; let __u32_sum: u128 = (u128::from(((((__v_237.as_canonical_u64() << 0) | (__v_238.as_canonical_u64() << 8)) | (__v_239.as_canonical_u64() << 16)) | (__v_240.as_canonical_u64() << 24))) + u128::from(((((__v_576.as_canonical_u64() << 0) | (__v_577.as_canonical_u64() << 8)) | (__v_574.as_canonical_u64() << 16)) | (__v_575.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_578: G = G::from_u8(__u32_bytes[0]); let __v_579: G = G::from_u8(__u32_bytes[1]); let __v_580: G = G::from_u8(__u32_bytes[2]); let __v_581: G = G::from_u8(__u32_bytes[3]); let __v_582: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_578; let __vj = __v_579; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_580; let __vj = __v_581; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_583: G = (__v_582 * __v_582); if (__v_583 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_583.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_189), (&__v_578)) } else { aiur::execute::bytes2_xor_split4_value(__v_189, __v_578, record) }; let __v_584: G = __b2_out.0; let __v_585: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_586: G = __b2_out.0; let __v_587: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_588: G = __b2_out.0; let __v_589: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_590: G = __b2_out.0; let __v_591: G = __b2_out.1; let __v_592: G = (__v_586 + __v_589); let __v_593: G = (__v_588 + __v_591); let __v_594: G = (__v_590 + __v_585); let __v_595: G = (__v_584 + __v_587); let __u32_sum: u128 = ((u128::from(((((__v_565.as_canonical_u64() << 0) | (__v_566.as_canonical_u64() << 8)) | (__v_567.as_canonical_u64() << 16)) | (__v_568.as_canonical_u64() << 24))) + u128::from(((((__v_592.as_canonical_u64() << 0) | (__v_593.as_canonical_u64() << 8)) | (__v_594.as_canonical_u64() << 16)) | (__v_595.as_canonical_u64() << 24)))) + u128::from(((((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8)) | (__v_126.as_canonical_u64() << 16)) | (__v_127.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_596: G = G::from_u8(__u32_bytes[0]); let __v_597: G = G::from_u8(__u32_bytes[1]); let __v_598: G = G::from_u8(__u32_bytes[2]); let __v_599: G = G::from_u8(__u32_bytes[3]); let __v_600: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_596; let __vj = __v_597; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_598; let __vj = __v_599; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_601: G = (__v_600 - __v_133); let __v_602: G = (__v_600 - __v_135); let __v_603: G = (__v_601 * __v_602); let __v_604: G = (__v_600 * __v_603); if (__v_604 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_604.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_605: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_596)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_596, record) }; let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_574), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_574, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __u32_sum: u128 = (u128::from(((((__v_578.as_canonical_u64() << 0) | (__v_579.as_canonical_u64() << 8)) | (__v_580.as_canonical_u64() << 16)) | (__v_581.as_canonical_u64() << 24))) + u128::from(((((__v_606.as_canonical_u64() << 0) | (__v_607.as_canonical_u64() << 8)) | (__v_608.as_canonical_u64() << 16)) | (__v_605.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_609: G = G::from_u8(__u32_bytes[0]); let __v_610: G = G::from_u8(__u32_bytes[1]); let __v_611: G = G::from_u8(__u32_bytes[2]); let __v_612: G = G::from_u8(__u32_bytes[3]); let __v_613: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_609; let __vj = __v_610; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_611; let __vj = __v_612; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_614: G = (__v_613 * __v_613); if (__v_614 != __v_613) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_613.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_592), (&__v_609)) } else { aiur::execute::bytes2_xor_split7_value(__v_592, __v_609, record) }; let __v_615: G = __b2_out.0; let __v_616: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_617: G = __b2_out.0; let __v_618: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_619: G = __b2_out.0; let __v_620: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_621: G = __b2_out.0; let __v_622: G = __b2_out.1; let __v_623: G = (__v_615 + __v_618); let __v_624: G = (__v_617 + __v_620); let __v_625: G = (__v_619 + __v_622); let __v_626: G = (__v_621 + __v_616); let __ret: [G; OUT_81] = [__v_410, __v_411, __v_412, __v_413, __v_472, __v_473, __v_474, __v_475, __v_534, __v_535, __v_536, __v_537, __v_596, __v_597, __v_598, __v_599, __v_623, __v_624, __v_625, __v_626, __v_437, __v_438, __v_439, __v_440, __v_499, __v_500, __v_501, __v_502, __v_561, __v_562, __v_563, __v_564, __v_547, __v_548, __v_549, __v_550, __v_609, __v_610, __v_611, __v_612, __v_423, __v_424, __v_425, __v_426, __v_485, __v_486, __v_487, __v_488, __v_482, __v_483, __v_484, __v_481, __v_544, __v_545, __v_546, __v_543, __v_606, __v_607, __v_608, __v_605, __v_420, __v_421, __v_422, __v_419, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; record.function_queries[81].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_81(inp: [G; IN_81], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __u32_sum: u128 = (u128::from((((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8)) | (__v_2.as_canonical_u64() << 16)) | (__v_3.as_canonical_u64() << 24)) + u128::from((((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8)) | (__v_18.as_canonical_u64() << 16)) | (__v_19.as_canonical_u64() << 24))) + u128::from((((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8)) | (__v_66.as_canonical_u64() << 16)) | (__v_67.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); let __v_129: G = G::from_u8(__u32_bytes[1]); let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_133: G = G::from_u64(1); let __v_134: G = __v_132 - __v_133; let __v_135: G = G::from_u64(2); let __v_136: G = __v_132 - __v_135; let __v_137: G = __v_134 * __v_136; let __v_138: G = __v_132 * __v_137; let __v_139: G = G::from_u64(0); if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_48, &__v_128) } else { aiur::execute::bytes2_xor_value(__v_48, __v_128, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_49, &__v_129) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_50, &__v_130) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_51, &__v_131) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __u32_sum: u128 = u128::from((((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8)) | (__v_34.as_canonical_u64() << 16)) | (__v_35.as_canonical_u64() << 24)) + u128::from((((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8)) | (__v_140.as_canonical_u64() << 16)) | (__v_141.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); let __v_145: G = G::from_u8(__u32_bytes[1]); let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_149: G = __v_148 * __v_148; if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_16, &__v_144) } else { aiur::execute::bytes2_xor_split4_value(__v_16, __v_144, record) }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_17, &__v_145) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_18, &__v_146) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_19, &__v_147) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = __v_152 + __v_155; let __v_159: G = __v_154 + __v_157; let __v_160: G = __v_156 + __v_151; let __v_161: G = __v_150 + __v_153; let __u32_sum: u128 = (u128::from((((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8)) | (__v_130.as_canonical_u64() << 16)) | (__v_131.as_canonical_u64() << 24)) + u128::from((((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8)) | (__v_160.as_canonical_u64() << 16)) | (__v_161.as_canonical_u64() << 24))) + u128::from((((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8)) | (__v_70.as_canonical_u64() << 16)) | (__v_71.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_162: G = G::from_u8(__u32_bytes[0]); let __v_163: G = G::from_u8(__u32_bytes[1]); let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_167: G = __v_166 - __v_133; let __v_168: G = __v_166 - __v_135; let __v_169: G = __v_167 * __v_168; let __v_170: G = __v_166 * __v_169; if (__v_170 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_171: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_142, &__v_162) } else { aiur::execute::bytes2_xor_value(__v_142, __v_162, record) }; let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_143, &__v_163) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_140, &__v_164) } else { aiur::execute::bytes2_xor_value(__v_140, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_141, &__v_165) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __u32_sum: u128 = u128::from((((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8)) | (__v_146.as_canonical_u64() << 16)) | (__v_147.as_canonical_u64() << 24)) + u128::from((((__v_172.as_canonical_u64() << 0) | (__v_173.as_canonical_u64() << 8)) | (__v_174.as_canonical_u64() << 16)) | (__v_171.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_175: G = G::from_u8(__u32_bytes[0]); let __v_176: G = G::from_u8(__u32_bytes[1]); let __v_177: G = G::from_u8(__u32_bytes[2]); let __v_178: G = G::from_u8(__u32_bytes[3]); let __v_179: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_175; let __vj = __v_176; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_177; let __vj = __v_178; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_180: G = __v_179 * __v_179; if (__v_180 != __v_179) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_179.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_158, &__v_175) } else { aiur::execute::bytes2_xor_split7_value(__v_158, __v_175, record) }; let __v_181: G = __b2_out.0; let __v_182: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_159, &__v_176) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_183: G = __b2_out.0; let __v_184: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_160, &__v_177) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_161, &__v_178) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; let __v_189: G = __v_181 + __v_184; let __v_190: G = __v_183 + __v_186; let __v_191: G = __v_185 + __v_188; let __v_192: G = __v_187 + __v_182; let __u32_sum: u128 = (u128::from((((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8)) | (__v_6.as_canonical_u64() << 16)) | (__v_7.as_canonical_u64() << 24)) + u128::from((((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8)) | (__v_22.as_canonical_u64() << 16)) | (__v_23.as_canonical_u64() << 24))) + u128::from((((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8)) | (__v_74.as_canonical_u64() << 16)) | (__v_75.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_193: G = G::from_u8(__u32_bytes[0]); let __v_194: G = G::from_u8(__u32_bytes[1]); let __v_195: G = G::from_u8(__u32_bytes[2]); let __v_196: G = G::from_u8(__u32_bytes[3]); let __v_197: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_193; let __vj = __v_194; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_195; let __vj = __v_196; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_198: G = __v_197 - __v_133; let __v_199: G = __v_197 - __v_135; let __v_200: G = __v_198 * __v_199; let __v_201: G = __v_197 * __v_200; if (__v_201 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_202: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_52, &__v_193) } else { aiur::execute::bytes2_xor_value(__v_52, __v_193, record) }; let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_53, &__v_194) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_54, &__v_195) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_55, &__v_196) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __u32_sum: u128 = u128::from((((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8)) | (__v_38.as_canonical_u64() << 16)) | (__v_39.as_canonical_u64() << 24)) + u128::from((((__v_204.as_canonical_u64() << 0) | (__v_205.as_canonical_u64() << 8)) | (__v_202.as_canonical_u64() << 16)) | (__v_203.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_206: G = G::from_u8(__u32_bytes[0]); let __v_207: G = G::from_u8(__u32_bytes[1]); let __v_208: G = G::from_u8(__u32_bytes[2]); let __v_209: G = G::from_u8(__u32_bytes[3]); let __v_210: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_206; let __vj = __v_207; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_208; let __vj = __v_209; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_211: G = __v_210 * __v_210; if (__v_211 != __v_210) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_210.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_20, &__v_206) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_206, record) }; let __v_212: G = __b2_out.0; let __v_213: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_21, &__v_207) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_214: G = __b2_out.0; let __v_215: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_22, &__v_208) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_216: G = __b2_out.0; let __v_217: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_23, &__v_209) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; let __v_220: G = __v_214 + __v_217; let __v_221: G = __v_216 + __v_219; let __v_222: G = __v_218 + __v_213; let __v_223: G = __v_212 + __v_215; let __u32_sum: u128 = (u128::from((((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8)) | (__v_195.as_canonical_u64() << 16)) | (__v_196.as_canonical_u64() << 24)) + u128::from((((__v_220.as_canonical_u64() << 0) | (__v_221.as_canonical_u64() << 8)) | (__v_222.as_canonical_u64() << 16)) | (__v_223.as_canonical_u64() << 24))) + u128::from((((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8)) | (__v_78.as_canonical_u64() << 16)) | (__v_79.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_224: G = G::from_u8(__u32_bytes[0]); let __v_225: G = G::from_u8(__u32_bytes[1]); let __v_226: G = G::from_u8(__u32_bytes[2]); let __v_227: G = G::from_u8(__u32_bytes[3]); let __v_228: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_224; let __vj = __v_225; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_226; let __vj = __v_227; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_229: G = __v_228 - __v_133; let __v_230: G = __v_228 - __v_135; let __v_231: G = __v_229 * __v_230; let __v_232: G = __v_228 * __v_231; if (__v_232 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_233: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_204, &__v_224) } else { aiur::execute::bytes2_xor_value(__v_204, __v_224, record) }; let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_205, &__v_225) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_202, &__v_226) } else { aiur::execute::bytes2_xor_value(__v_202, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_203, &__v_227) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __u32_sum: u128 = u128::from((((__v_206.as_canonical_u64() << 0) | (__v_207.as_canonical_u64() << 8)) | (__v_208.as_canonical_u64() << 16)) | (__v_209.as_canonical_u64() << 24)) + u128::from((((__v_234.as_canonical_u64() << 0) | (__v_235.as_canonical_u64() << 8)) | (__v_236.as_canonical_u64() << 16)) | (__v_233.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_237: G = G::from_u8(__u32_bytes[0]); let __v_238: G = G::from_u8(__u32_bytes[1]); let __v_239: G = G::from_u8(__u32_bytes[2]); let __v_240: G = G::from_u8(__u32_bytes[3]); let __v_241: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_239; let __vj = __v_240; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_242: G = __v_241 * __v_241; if (__v_242 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_220, &__v_237) } else { aiur::execute::bytes2_xor_split7_value(__v_220, __v_237, record) }; let __v_243: G = __b2_out.0; let __v_244: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_221, &__v_238) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_245: G = __b2_out.0; let __v_246: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_222, &__v_239) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_247: G = __b2_out.0; let __v_248: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_223, &__v_240) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_249: G = __b2_out.0; let __v_250: G = __b2_out.1; let __v_251: G = __v_243 + __v_246; let __v_252: G = __v_245 + __v_248; let __v_253: G = __v_247 + __v_250; let __v_254: G = __v_249 + __v_244; let __u32_sum: u128 = (u128::from((((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8)) | (__v_10.as_canonical_u64() << 16)) | (__v_11.as_canonical_u64() << 24)) + u128::from((((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8)) | (__v_26.as_canonical_u64() << 16)) | (__v_27.as_canonical_u64() << 24))) + u128::from((((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8)) | (__v_82.as_canonical_u64() << 16)) | (__v_83.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_255: G = G::from_u8(__u32_bytes[0]); let __v_256: G = G::from_u8(__u32_bytes[1]); let __v_257: G = G::from_u8(__u32_bytes[2]); let __v_258: G = G::from_u8(__u32_bytes[3]); let __v_259: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_255; let __vj = __v_256; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_257; let __vj = __v_258; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_260: G = __v_259 - __v_133; let __v_261: G = __v_259 - __v_135; let __v_262: G = __v_260 * __v_261; let __v_263: G = __v_259 * __v_262; if (__v_263 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_263.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_264: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_56, &__v_255) } else { aiur::execute::bytes2_xor_value(__v_56, __v_255, record) }; let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_57, &__v_256) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_58, &__v_257) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_59, &__v_258) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __u32_sum: u128 = u128::from((((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8)) | (__v_42.as_canonical_u64() << 16)) | (__v_43.as_canonical_u64() << 24)) + u128::from((((__v_266.as_canonical_u64() << 0) | (__v_267.as_canonical_u64() << 8)) | (__v_264.as_canonical_u64() << 16)) | (__v_265.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_268: G = G::from_u8(__u32_bytes[0]); let __v_269: G = G::from_u8(__u32_bytes[1]); let __v_270: G = G::from_u8(__u32_bytes[2]); let __v_271: G = G::from_u8(__u32_bytes[3]); let __v_272: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_273: G = __v_272 * __v_272; if (__v_273 != __v_272) { return Err(ExecError::AssertEqMismatch { lhs: __v_273.as_canonical_u64(), rhs: __v_272.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_24, &__v_268) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_268, record) }; let __v_274: G = __b2_out.0; let __v_275: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_25, &__v_269) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_276: G = __b2_out.0; let __v_277: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_26, &__v_270) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_278: G = __b2_out.0; let __v_279: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_27, &__v_271) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_280: G = __b2_out.0; let __v_281: G = __b2_out.1; let __v_282: G = __v_276 + __v_279; let __v_283: G = __v_278 + __v_281; let __v_284: G = __v_280 + __v_275; let __v_285: G = __v_274 + __v_277; let __u32_sum: u128 = (u128::from((((__v_255.as_canonical_u64() << 0) | (__v_256.as_canonical_u64() << 8)) | (__v_257.as_canonical_u64() << 16)) | (__v_258.as_canonical_u64() << 24)) + u128::from((((__v_282.as_canonical_u64() << 0) | (__v_283.as_canonical_u64() << 8)) | (__v_284.as_canonical_u64() << 16)) | (__v_285.as_canonical_u64() << 24))) + u128::from((((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8)) | (__v_86.as_canonical_u64() << 16)) | (__v_87.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_286: G = G::from_u8(__u32_bytes[0]); let __v_287: G = G::from_u8(__u32_bytes[1]); let __v_288: G = G::from_u8(__u32_bytes[2]); let __v_289: G = G::from_u8(__u32_bytes[3]); let __v_290: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_286; let __vj = __v_287; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_288; let __vj = __v_289; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_291: G = __v_290 - __v_133; let __v_292: G = __v_290 - __v_135; let __v_293: G = __v_291 * __v_292; let __v_294: G = __v_290 * __v_293; if (__v_294 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_294.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_295: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_266, &__v_286) } else { aiur::execute::bytes2_xor_value(__v_266, __v_286, record) }; let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_267, &__v_287) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_264, &__v_288) } else { aiur::execute::bytes2_xor_value(__v_264, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_265, &__v_289) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __u32_sum: u128 = u128::from((((__v_268.as_canonical_u64() << 0) | (__v_269.as_canonical_u64() << 8)) | (__v_270.as_canonical_u64() << 16)) | (__v_271.as_canonical_u64() << 24)) + u128::from((((__v_296.as_canonical_u64() << 0) | (__v_297.as_canonical_u64() << 8)) | (__v_298.as_canonical_u64() << 16)) | (__v_295.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_299: G = G::from_u8(__u32_bytes[0]); let __v_300: G = G::from_u8(__u32_bytes[1]); let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_304: G = __v_303 * __v_303; if (__v_304 != __v_303) { return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_303.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_282, &__v_299) } else { aiur::execute::bytes2_xor_split7_value(__v_282, __v_299, record) }; let __v_305: G = __b2_out.0; let __v_306: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_283, &__v_300) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_307: G = __b2_out.0; let __v_308: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_284, &__v_301) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_309: G = __b2_out.0; let __v_310: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_285, &__v_302) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_311: G = __b2_out.0; let __v_312: G = __b2_out.1; let __v_313: G = __v_305 + __v_308; let __v_314: G = __v_307 + __v_310; let __v_315: G = __v_309 + __v_312; let __v_316: G = __v_311 + __v_306; let __u32_sum: u128 = (u128::from((((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8)) | (__v_14.as_canonical_u64() << 16)) | (__v_15.as_canonical_u64() << 24)) + u128::from((((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8)) | (__v_30.as_canonical_u64() << 16)) | (__v_31.as_canonical_u64() << 24))) + u128::from((((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8)) | (__v_90.as_canonical_u64() << 16)) | (__v_91.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_317: G = G::from_u8(__u32_bytes[0]); let __v_318: G = G::from_u8(__u32_bytes[1]); let __v_319: G = G::from_u8(__u32_bytes[2]); let __v_320: G = G::from_u8(__u32_bytes[3]); let __v_321: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_319; let __vj = __v_320; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_322: G = __v_321 - __v_133; let __v_323: G = __v_321 - __v_135; let __v_324: G = __v_322 * __v_323; let __v_325: G = __v_321 * __v_324; if (__v_325 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_325.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_326: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_60, &__v_317) } else { aiur::execute::bytes2_xor_value(__v_60, __v_317, record) }; let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_61, &__v_318) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_62, &__v_319) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_63, &__v_320) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __u32_sum: u128 = u128::from((((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8)) | (__v_46.as_canonical_u64() << 16)) | (__v_47.as_canonical_u64() << 24)) + u128::from((((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8)) | (__v_326.as_canonical_u64() << 16)) | (__v_327.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_330: G = G::from_u8(__u32_bytes[0]); let __v_331: G = G::from_u8(__u32_bytes[1]); let __v_332: G = G::from_u8(__u32_bytes[2]); let __v_333: G = G::from_u8(__u32_bytes[3]); let __v_334: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_330; let __vj = __v_331; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_335: G = __v_334 * __v_334; if (__v_335 != __v_334) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_334.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_28, &__v_330) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_330, record) }; let __v_336: G = __b2_out.0; let __v_337: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_29, &__v_331) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_338: G = __b2_out.0; let __v_339: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_30, &__v_332) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_340: G = __b2_out.0; let __v_341: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_31, &__v_333) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_342: G = __b2_out.0; let __v_343: G = __b2_out.1; let __v_344: G = __v_338 + __v_341; let __v_345: G = __v_340 + __v_343; let __v_346: G = __v_342 + __v_337; let __v_347: G = __v_336 + __v_339; let __u32_sum: u128 = (u128::from((((__v_317.as_canonical_u64() << 0) | (__v_318.as_canonical_u64() << 8)) | (__v_319.as_canonical_u64() << 16)) | (__v_320.as_canonical_u64() << 24)) + u128::from((((__v_344.as_canonical_u64() << 0) | (__v_345.as_canonical_u64() << 8)) | (__v_346.as_canonical_u64() << 16)) | (__v_347.as_canonical_u64() << 24))) + u128::from((((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8)) | (__v_94.as_canonical_u64() << 16)) | (__v_95.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); let __v_349: G = G::from_u8(__u32_bytes[1]); let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_353: G = __v_352 - __v_133; let __v_354: G = __v_352 - __v_135; let __v_355: G = __v_353 * __v_354; let __v_356: G = __v_352 * __v_355; if (__v_356 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_357: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_328, &__v_348) } else { aiur::execute::bytes2_xor_value(__v_328, __v_348, record) }; let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_329, &__v_349) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_326, &__v_350) } else { aiur::execute::bytes2_xor_value(__v_326, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_327, &__v_351) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __u32_sum: u128 = u128::from((((__v_330.as_canonical_u64() << 0) | (__v_331.as_canonical_u64() << 8)) | (__v_332.as_canonical_u64() << 16)) | (__v_333.as_canonical_u64() << 24)) + u128::from((((__v_358.as_canonical_u64() << 0) | (__v_359.as_canonical_u64() << 8)) | (__v_360.as_canonical_u64() << 16)) | (__v_357.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_361: G = G::from_u8(__u32_bytes[0]); let __v_362: G = G::from_u8(__u32_bytes[1]); let __v_363: G = G::from_u8(__u32_bytes[2]); let __v_364: G = G::from_u8(__u32_bytes[3]); let __v_365: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_361; let __vj = __v_362; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_363; let __vj = __v_364; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_366: G = __v_365 * __v_365; if (__v_366 != __v_365) { return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_365.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_344, &__v_361) } else { aiur::execute::bytes2_xor_split7_value(__v_344, __v_361, record) }; let __v_367: G = __b2_out.0; let __v_368: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_345, &__v_362) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_369: G = __b2_out.0; let __v_370: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_346, &__v_363) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_371: G = __b2_out.0; let __v_372: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_347, &__v_364) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_373: G = __b2_out.0; let __v_374: G = __b2_out.1; let __v_375: G = __v_367 + __v_370; let __v_376: G = __v_369 + __v_372; let __v_377: G = __v_371 + __v_374; let __v_378: G = __v_373 + __v_368; let __u32_sum: u128 = (u128::from((((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8)) | (__v_164.as_canonical_u64() << 16)) | (__v_165.as_canonical_u64() << 24)) + u128::from((((__v_251.as_canonical_u64() << 0) | (__v_252.as_canonical_u64() << 8)) | (__v_253.as_canonical_u64() << 16)) | (__v_254.as_canonical_u64() << 24))) + u128::from((((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8)) | (__v_98.as_canonical_u64() << 16)) | (__v_99.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_379: G = G::from_u8(__u32_bytes[0]); let __v_380: G = G::from_u8(__u32_bytes[1]); let __v_381: G = G::from_u8(__u32_bytes[2]); let __v_382: G = G::from_u8(__u32_bytes[3]); let __v_383: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_379; let __vj = __v_380; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_381; let __vj = __v_382; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_384: G = __v_383 - __v_133; let __v_385: G = __v_383 - __v_135; let __v_386: G = __v_384 * __v_385; let __v_387: G = __v_383 * __v_386; if (__v_387 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_388: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_358, &__v_379) } else { aiur::execute::bytes2_xor_value(__v_358, __v_379, record) }; let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_359, &__v_380) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_360, &__v_381) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_357, &__v_382) } else { aiur::execute::bytes2_xor_value(__v_357, __v_382, record) }; let __u32_sum: u128 = u128::from((((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8)) | (__v_301.as_canonical_u64() << 16)) | (__v_302.as_canonical_u64() << 24)) + u128::from((((__v_390.as_canonical_u64() << 0) | (__v_391.as_canonical_u64() << 8)) | (__v_388.as_canonical_u64() << 16)) | (__v_389.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_392: G = G::from_u8(__u32_bytes[0]); let __v_393: G = G::from_u8(__u32_bytes[1]); let __v_394: G = G::from_u8(__u32_bytes[2]); let __v_395: G = G::from_u8(__u32_bytes[3]); let __v_396: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_392; let __vj = __v_393; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_394; let __vj = __v_395; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_397: G = __v_396 * __v_396; if (__v_397 != __v_396) { return Err(ExecError::AssertEqMismatch { lhs: __v_397.as_canonical_u64(), rhs: __v_396.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_251, &__v_392) } else { aiur::execute::bytes2_xor_split4_value(__v_251, __v_392, record) }; let __v_398: G = __b2_out.0; let __v_399: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_252, &__v_393) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_400: G = __b2_out.0; let __v_401: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_253, &__v_394) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_402: G = __b2_out.0; let __v_403: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_254, &__v_395) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_404: G = __b2_out.0; let __v_405: G = __b2_out.1; let __v_406: G = __v_400 + __v_403; let __v_407: G = __v_402 + __v_405; let __v_408: G = __v_404 + __v_399; let __v_409: G = __v_398 + __v_401; let __u32_sum: u128 = (u128::from((((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8)) | (__v_381.as_canonical_u64() << 16)) | (__v_382.as_canonical_u64() << 24)) + u128::from((((__v_406.as_canonical_u64() << 0) | (__v_407.as_canonical_u64() << 8)) | (__v_408.as_canonical_u64() << 16)) | (__v_409.as_canonical_u64() << 24))) + u128::from((((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8)) | (__v_102.as_canonical_u64() << 16)) | (__v_103.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_410: G = G::from_u8(__u32_bytes[0]); let __v_411: G = G::from_u8(__u32_bytes[1]); let __v_412: G = G::from_u8(__u32_bytes[2]); let __v_413: G = G::from_u8(__u32_bytes[3]); let __v_414: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_410; let __vj = __v_411; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_412; let __vj = __v_413; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_415: G = __v_414 - __v_133; let __v_416: G = __v_414 - __v_135; let __v_417: G = __v_415 * __v_416; let __v_418: G = __v_414 * __v_417; if (__v_418 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_418.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_419: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_390, &__v_410) } else { aiur::execute::bytes2_xor_value(__v_390, __v_410, record) }; let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_391, &__v_411) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_388, &__v_412) } else { aiur::execute::bytes2_xor_value(__v_388, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_389, &__v_413) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __u32_sum: u128 = u128::from((((__v_392.as_canonical_u64() << 0) | (__v_393.as_canonical_u64() << 8)) | (__v_394.as_canonical_u64() << 16)) | (__v_395.as_canonical_u64() << 24)) + u128::from((((__v_420.as_canonical_u64() << 0) | (__v_421.as_canonical_u64() << 8)) | (__v_422.as_canonical_u64() << 16)) | (__v_419.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_423: G = G::from_u8(__u32_bytes[0]); let __v_424: G = G::from_u8(__u32_bytes[1]); let __v_425: G = G::from_u8(__u32_bytes[2]); let __v_426: G = G::from_u8(__u32_bytes[3]); let __v_427: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_423; let __vj = __v_424; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_425; let __vj = __v_426; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_428: G = __v_427 * __v_427; if (__v_428 != __v_427) { return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_427.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_406, &__v_423) } else { aiur::execute::bytes2_xor_split7_value(__v_406, __v_423, record) }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_407, &__v_424) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_431: G = __b2_out.0; let __v_432: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_408, &__v_425) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_433: G = __b2_out.0; let __v_434: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_409, &__v_426) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_435: G = __b2_out.0; let __v_436: G = __b2_out.1; let __v_437: G = __v_429 + __v_432; let __v_438: G = __v_431 + __v_434; let __v_439: G = __v_433 + __v_436; let __v_440: G = __v_435 + __v_430; let __u32_sum: u128 = (u128::from((((__v_224.as_canonical_u64() << 0) | (__v_225.as_canonical_u64() << 8)) | (__v_226.as_canonical_u64() << 16)) | (__v_227.as_canonical_u64() << 24)) + u128::from((((__v_313.as_canonical_u64() << 0) | (__v_314.as_canonical_u64() << 8)) | (__v_315.as_canonical_u64() << 16)) | (__v_316.as_canonical_u64() << 24))) + u128::from((((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8)) | (__v_106.as_canonical_u64() << 16)) | (__v_107.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_441: G = G::from_u8(__u32_bytes[0]); let __v_442: G = G::from_u8(__u32_bytes[1]); let __v_443: G = G::from_u8(__u32_bytes[2]); let __v_444: G = G::from_u8(__u32_bytes[3]); let __v_445: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_441; let __vj = __v_442; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_443; let __vj = __v_444; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_446: G = __v_445 - __v_133; let __v_447: G = __v_445 - __v_135; let __v_448: G = __v_446 * __v_447; let __v_449: G = __v_445 * __v_448; if (__v_449 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_449.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_450: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_172, &__v_441) } else { aiur::execute::bytes2_xor_value(__v_172, __v_441, record) }; let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_173, &__v_442) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_174, &__v_443) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_171, &__v_444) } else { aiur::execute::bytes2_xor_value(__v_171, __v_444, record) }; let __u32_sum: u128 = u128::from((((__v_361.as_canonical_u64() << 0) | (__v_362.as_canonical_u64() << 8)) | (__v_363.as_canonical_u64() << 16)) | (__v_364.as_canonical_u64() << 24)) + u128::from((((__v_452.as_canonical_u64() << 0) | (__v_453.as_canonical_u64() << 8)) | (__v_450.as_canonical_u64() << 16)) | (__v_451.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_454: G = G::from_u8(__u32_bytes[0]); let __v_455: G = G::from_u8(__u32_bytes[1]); let __v_456: G = G::from_u8(__u32_bytes[2]); let __v_457: G = G::from_u8(__u32_bytes[3]); let __v_458: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_454; let __vj = __v_455; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_456; let __vj = __v_457; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_459: G = __v_458 * __v_458; if (__v_459 != __v_458) { return Err(ExecError::AssertEqMismatch { lhs: __v_459.as_canonical_u64(), rhs: __v_458.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_313, &__v_454) } else { aiur::execute::bytes2_xor_split4_value(__v_313, __v_454, record) }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_314, &__v_455) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_315, &__v_456) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_464: G = __b2_out.0; let __v_465: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_316, &__v_457) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_466: G = __b2_out.0; let __v_467: G = __b2_out.1; let __v_468: G = __v_462 + __v_465; let __v_469: G = __v_464 + __v_467; let __v_470: G = __v_466 + __v_461; let __v_471: G = __v_460 + __v_463; let __u32_sum: u128 = (u128::from((((__v_441.as_canonical_u64() << 0) | (__v_442.as_canonical_u64() << 8)) | (__v_443.as_canonical_u64() << 16)) | (__v_444.as_canonical_u64() << 24)) + u128::from((((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8)) | (__v_470.as_canonical_u64() << 16)) | (__v_471.as_canonical_u64() << 24))) + u128::from((((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8)) | (__v_110.as_canonical_u64() << 16)) | (__v_111.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_472: G = G::from_u8(__u32_bytes[0]); let __v_473: G = G::from_u8(__u32_bytes[1]); let __v_474: G = G::from_u8(__u32_bytes[2]); let __v_475: G = G::from_u8(__u32_bytes[3]); let __v_476: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_472; let __vj = __v_473; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_474; let __vj = __v_475; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_477: G = __v_476 - __v_133; let __v_478: G = __v_476 - __v_135; let __v_479: G = __v_477 * __v_478; let __v_480: G = __v_476 * __v_479; if (__v_480 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_481: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_452, &__v_472) } else { aiur::execute::bytes2_xor_value(__v_452, __v_472, record) }; let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_453, &__v_473) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_450, &__v_474) } else { aiur::execute::bytes2_xor_value(__v_450, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_451, &__v_475) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __u32_sum: u128 = u128::from((((__v_454.as_canonical_u64() << 0) | (__v_455.as_canonical_u64() << 8)) | (__v_456.as_canonical_u64() << 16)) | (__v_457.as_canonical_u64() << 24)) + u128::from((((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8)) | (__v_484.as_canonical_u64() << 16)) | (__v_481.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); let __v_486: G = G::from_u8(__u32_bytes[1]); let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_490: G = __v_489 * __v_489; if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_468, &__v_485) } else { aiur::execute::bytes2_xor_split7_value(__v_468, __v_485, record) }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_469, &__v_486) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_470, &__v_487) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_471, &__v_488) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = __v_491 + __v_494; let __v_500: G = __v_493 + __v_496; let __v_501: G = __v_495 + __v_498; let __v_502: G = __v_497 + __v_492; let __u32_sum: u128 = (u128::from((((__v_286.as_canonical_u64() << 0) | (__v_287.as_canonical_u64() << 8)) | (__v_288.as_canonical_u64() << 16)) | (__v_289.as_canonical_u64() << 24)) + u128::from((((__v_375.as_canonical_u64() << 0) | (__v_376.as_canonical_u64() << 8)) | (__v_377.as_canonical_u64() << 16)) | (__v_378.as_canonical_u64() << 24))) + u128::from((((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8)) | (__v_114.as_canonical_u64() << 16)) | (__v_115.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_503: G = G::from_u8(__u32_bytes[0]); let __v_504: G = G::from_u8(__u32_bytes[1]); let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_508: G = __v_507 - __v_133; let __v_509: G = __v_507 - __v_135; let __v_510: G = __v_508 * __v_509; let __v_511: G = __v_507 * __v_510; if (__v_511 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_512: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_234, &__v_503) } else { aiur::execute::bytes2_xor_value(__v_234, __v_503, record) }; let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_235, &__v_504) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_236, &__v_505) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_233, &__v_506) } else { aiur::execute::bytes2_xor_value(__v_233, __v_506, record) }; let __u32_sum: u128 = u128::from((((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8)) | (__v_177.as_canonical_u64() << 16)) | (__v_178.as_canonical_u64() << 24)) + u128::from((((__v_514.as_canonical_u64() << 0) | (__v_515.as_canonical_u64() << 8)) | (__v_512.as_canonical_u64() << 16)) | (__v_513.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_516: G = G::from_u8(__u32_bytes[0]); let __v_517: G = G::from_u8(__u32_bytes[1]); let __v_518: G = G::from_u8(__u32_bytes[2]); let __v_519: G = G::from_u8(__u32_bytes[3]); let __v_520: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_516; let __vj = __v_517; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_521: G = __v_520 * __v_520; if (__v_521 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_375, &__v_516) } else { aiur::execute::bytes2_xor_split4_value(__v_375, __v_516, record) }; let __v_522: G = __b2_out.0; let __v_523: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_376, &__v_517) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_377, &__v_518) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_378, &__v_519) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; let __v_530: G = __v_524 + __v_527; let __v_531: G = __v_526 + __v_529; let __v_532: G = __v_528 + __v_523; let __v_533: G = __v_522 + __v_525; let __u32_sum: u128 = (u128::from((((__v_503.as_canonical_u64() << 0) | (__v_504.as_canonical_u64() << 8)) | (__v_505.as_canonical_u64() << 16)) | (__v_506.as_canonical_u64() << 24)) + u128::from((((__v_530.as_canonical_u64() << 0) | (__v_531.as_canonical_u64() << 8)) | (__v_532.as_canonical_u64() << 16)) | (__v_533.as_canonical_u64() << 24))) + u128::from((((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8)) | (__v_118.as_canonical_u64() << 16)) | (__v_119.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_534: G = G::from_u8(__u32_bytes[0]); let __v_535: G = G::from_u8(__u32_bytes[1]); let __v_536: G = G::from_u8(__u32_bytes[2]); let __v_537: G = G::from_u8(__u32_bytes[3]); let __v_538: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_534; let __vj = __v_535; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_539: G = __v_538 - __v_133; let __v_540: G = __v_538 - __v_135; let __v_541: G = __v_539 * __v_540; let __v_542: G = __v_538 * __v_541; if (__v_542 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_542.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_543: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_514, &__v_534) } else { aiur::execute::bytes2_xor_value(__v_514, __v_534, record) }; let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_515, &__v_535) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_512, &__v_536) } else { aiur::execute::bytes2_xor_value(__v_512, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_513, &__v_537) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __u32_sum: u128 = u128::from((((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8)) | (__v_518.as_canonical_u64() << 16)) | (__v_519.as_canonical_u64() << 24)) + u128::from((((__v_544.as_canonical_u64() << 0) | (__v_545.as_canonical_u64() << 8)) | (__v_546.as_canonical_u64() << 16)) | (__v_543.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_547: G = G::from_u8(__u32_bytes[0]); let __v_548: G = G::from_u8(__u32_bytes[1]); let __v_549: G = G::from_u8(__u32_bytes[2]); let __v_550: G = G::from_u8(__u32_bytes[3]); let __v_551: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_547; let __vj = __v_548; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_549; let __vj = __v_550; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_552: G = __v_551 * __v_551; if (__v_552 != __v_551) { return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_551.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_530, &__v_547) } else { aiur::execute::bytes2_xor_split7_value(__v_530, __v_547, record) }; let __v_553: G = __b2_out.0; let __v_554: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_531, &__v_548) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_555: G = __b2_out.0; let __v_556: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_532, &__v_549) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_557: G = __b2_out.0; let __v_558: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_533, &__v_550) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; let __v_561: G = __v_553 + __v_556; let __v_562: G = __v_555 + __v_558; let __v_563: G = __v_557 + __v_560; let __v_564: G = __v_559 + __v_554; let __u32_sum: u128 = (u128::from((((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8)) | (__v_350.as_canonical_u64() << 16)) | (__v_351.as_canonical_u64() << 24)) + u128::from((((__v_189.as_canonical_u64() << 0) | (__v_190.as_canonical_u64() << 8)) | (__v_191.as_canonical_u64() << 16)) | (__v_192.as_canonical_u64() << 24))) + u128::from((((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8)) | (__v_122.as_canonical_u64() << 16)) | (__v_123.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_565: G = G::from_u8(__u32_bytes[0]); let __v_566: G = G::from_u8(__u32_bytes[1]); let __v_567: G = G::from_u8(__u32_bytes[2]); let __v_568: G = G::from_u8(__u32_bytes[3]); let __v_569: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_565; let __vj = __v_566; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_567; let __vj = __v_568; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_570: G = __v_569 - __v_133; let __v_571: G = __v_569 - __v_135; let __v_572: G = __v_570 * __v_571; let __v_573: G = __v_569 * __v_572; if (__v_573 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_574: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_296, &__v_565) } else { aiur::execute::bytes2_xor_value(__v_296, __v_565, record) }; let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_297, &__v_566) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_298, &__v_567) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_295, &__v_568) } else { aiur::execute::bytes2_xor_value(__v_295, __v_568, record) }; let __u32_sum: u128 = u128::from((((__v_237.as_canonical_u64() << 0) | (__v_238.as_canonical_u64() << 8)) | (__v_239.as_canonical_u64() << 16)) | (__v_240.as_canonical_u64() << 24)) + u128::from((((__v_576.as_canonical_u64() << 0) | (__v_577.as_canonical_u64() << 8)) | (__v_574.as_canonical_u64() << 16)) | (__v_575.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_578: G = G::from_u8(__u32_bytes[0]); let __v_579: G = G::from_u8(__u32_bytes[1]); let __v_580: G = G::from_u8(__u32_bytes[2]); let __v_581: G = G::from_u8(__u32_bytes[3]); let __v_582: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_578; let __vj = __v_579; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_580; let __vj = __v_581; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_583: G = __v_582 * __v_582; if (__v_583 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_583.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_189, &__v_578) } else { aiur::execute::bytes2_xor_split4_value(__v_189, __v_578, record) }; let __v_584: G = __b2_out.0; let __v_585: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_190, &__v_579) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_586: G = __b2_out.0; let __v_587: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_191, &__v_580) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_588: G = __b2_out.0; let __v_589: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_192, &__v_581) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_590: G = __b2_out.0; let __v_591: G = __b2_out.1; let __v_592: G = __v_586 + __v_589; let __v_593: G = __v_588 + __v_591; let __v_594: G = __v_590 + __v_585; let __v_595: G = __v_584 + __v_587; let __u32_sum: u128 = (u128::from((((__v_565.as_canonical_u64() << 0) | (__v_566.as_canonical_u64() << 8)) | (__v_567.as_canonical_u64() << 16)) | (__v_568.as_canonical_u64() << 24)) + u128::from((((__v_592.as_canonical_u64() << 0) | (__v_593.as_canonical_u64() << 8)) | (__v_594.as_canonical_u64() << 16)) | (__v_595.as_canonical_u64() << 24))) + u128::from((((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8)) | (__v_126.as_canonical_u64() << 16)) | (__v_127.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_596: G = G::from_u8(__u32_bytes[0]); let __v_597: G = G::from_u8(__u32_bytes[1]); let __v_598: G = G::from_u8(__u32_bytes[2]); let __v_599: G = G::from_u8(__u32_bytes[3]); let __v_600: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_596; let __vj = __v_597; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_598; let __vj = __v_599; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_601: G = __v_600 - __v_133; let __v_602: G = __v_600 - __v_135; let __v_603: G = __v_601 * __v_602; let __v_604: G = __v_600 * __v_603; if (__v_604 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_604.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_605: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_576, &__v_596) } else { aiur::execute::bytes2_xor_value(__v_576, __v_596, record) }; let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_577, &__v_597) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_574, &__v_598) } else { aiur::execute::bytes2_xor_value(__v_574, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_575, &__v_599) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __u32_sum: u128 = u128::from((((__v_578.as_canonical_u64() << 0) | (__v_579.as_canonical_u64() << 8)) | (__v_580.as_canonical_u64() << 16)) | (__v_581.as_canonical_u64() << 24)) + u128::from((((__v_606.as_canonical_u64() << 0) | (__v_607.as_canonical_u64() << 8)) | (__v_608.as_canonical_u64() << 16)) | (__v_605.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_609: G = G::from_u8(__u32_bytes[0]); let __v_610: G = G::from_u8(__u32_bytes[1]); let __v_611: G = G::from_u8(__u32_bytes[2]); let __v_612: G = G::from_u8(__u32_bytes[3]); let __v_613: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_609; let __vj = __v_610; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_611; let __vj = __v_612; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_614: G = __v_613 * __v_613; if (__v_614 != __v_613) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_613.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_592, &__v_609) } else { aiur::execute::bytes2_xor_split7_value(__v_592, __v_609, record) }; let __v_615: G = __b2_out.0; let __v_616: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_593, &__v_610) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_617: G = __b2_out.0; let __v_618: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_594, &__v_611) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_619: G = __b2_out.0; let __v_620: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_595, &__v_612) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_621: G = __b2_out.0; let __v_622: G = __b2_out.1; let __v_623: G = __v_615 + __v_618; let __v_624: G = __v_617 + __v_620; let __v_625: G = __v_619 + __v_622; let __v_626: G = __v_621 + __v_616; let __ret: [G; OUT_81] = [__v_410, __v_411, __v_412, __v_413, __v_472, __v_473, __v_474, __v_475, __v_534, __v_535, __v_536, __v_537, __v_596, __v_597, __v_598, __v_599, __v_623, __v_624, __v_625, __v_626, __v_437, __v_438, __v_439, __v_440, __v_499, __v_500, __v_501, __v_502, __v_561, __v_562, __v_563, __v_564, __v_547, __v_548, __v_549, __v_550, __v_609, __v_610, __v_611, __v_612, __v_423, __v_424, __v_425, __v_426, __v_485, __v_486, __v_487, __v_488, __v_482, __v_483, __v_484, __v_481, __v_544, __v_545, __v_546, __v_543, __v_606, __v_607, __v_608, __v_605, __v_420, __v_421, __v_422, __v_419, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_82: usize = 106; const IN_82: usize = 106; const OUT_82: usize = 32; -fn aiur_fn_82(inp: [G; IN_82], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); let __v_109: G = G::from_u64(106); let __v_110: G = G::from_u64(133); let __v_111: G = G::from_u64(174); let __v_112: G = G::from_u64(187); let __v_113: G = G::from_u64(114); let __v_114: G = G::from_u64(243); let __v_115: G = G::from_u64(110); let __v_116: G = G::from_u64(60); let __v_117: G = G::from_u64(58); let __v_118: G = G::from_u64(245); let __v_119: G = G::from_u64(79); let __v_120: G = G::from_u64(165); let __v_121: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_121, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_106, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_121, __v_121, __v_121, __v_105, __v_121, __v_121, __v_121, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; let __v_125: G = __r_arr[3]; let __v_126: G = __r_arr[4]; let __v_127: G = __r_arr[5]; let __v_128: G = __r_arr[6]; let __v_129: G = __r_arr[7]; let __v_130: G = __r_arr[8]; let __v_131: G = __r_arr[9]; let __v_132: G = __r_arr[10]; let __v_133: G = __r_arr[11]; let __v_134: G = __r_arr[12]; let __v_135: G = __r_arr[13]; let __v_136: G = __r_arr[14]; let __v_137: G = __r_arr[15]; let __v_138: G = __r_arr[16]; let __v_139: G = __r_arr[17]; let __v_140: G = __r_arr[18]; let __v_141: G = __r_arr[19]; let __v_142: G = __r_arr[20]; let __v_143: G = __r_arr[21]; let __v_144: G = __r_arr[22]; let __v_145: G = __r_arr[23]; let __v_146: G = __r_arr[24]; let __v_147: G = __r_arr[25]; let __v_148: G = __r_arr[26]; let __v_149: G = __r_arr[27]; let __v_150: G = __r_arr[28]; let __v_151: G = __r_arr[29]; let __v_152: G = __r_arr[30]; let __v_153: G = __r_arr[31]; let __ret: [G; OUT_82] = [__v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153]; record.function_queries[82].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_82(inp: [G; IN_82], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); let __v_109: G = G::from_u64(106); let __v_110: G = G::from_u64(133); let __v_111: G = G::from_u64(174); let __v_112: G = G::from_u64(187); let __v_113: G = G::from_u64(114); let __v_114: G = G::from_u64(243); let __v_115: G = G::from_u64(110); let __v_116: G = G::from_u64(60); let __v_117: G = G::from_u64(58); let __v_118: G = G::from_u64(245); let __v_119: G = G::from_u64(79); let __v_120: G = G::from_u64(165); let __v_121: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_121, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_106, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_121, __v_121, __v_121, __v_105, __v_121, __v_121, __v_121, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; let __v_125: G = __r_arr[3]; let __v_126: G = __r_arr[4]; let __v_127: G = __r_arr[5]; let __v_128: G = __r_arr[6]; let __v_129: G = __r_arr[7]; let __v_130: G = __r_arr[8]; let __v_131: G = __r_arr[9]; let __v_132: G = __r_arr[10]; let __v_133: G = __r_arr[11]; let __v_134: G = __r_arr[12]; let __v_135: G = __r_arr[13]; let __v_136: G = __r_arr[14]; let __v_137: G = __r_arr[15]; let __v_138: G = __r_arr[16]; let __v_139: G = __r_arr[17]; let __v_140: G = __r_arr[18]; let __v_141: G = __r_arr[19]; let __v_142: G = __r_arr[20]; let __v_143: G = __r_arr[21]; let __v_144: G = __r_arr[22]; let __v_145: G = __r_arr[23]; let __v_146: G = __r_arr[24]; let __v_147: G = __r_arr[25]; let __v_148: G = __r_arr[26]; let __v_149: G = __r_arr[27]; let __v_150: G = __r_arr[28]; let __v_151: G = __r_arr[29]; let __v_152: G = __r_arr[30]; let __v_153: G = __r_arr[31]; let __ret: [G; OUT_82] = [__v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_83: usize = 129; const IN_83: usize = 129; const OUT_83: usize = 32; -fn aiur_fn_83(inp: [G; IN_83], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __v_128: G = inp[128]; match __v_0.as_canonical_u64() { 7u64 => { let __v_129: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_1), (&__v_33)) } else { aiur::execute::bytes2_xor_value(__v_1, __v_33, record) }; let __v_130: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_2), (&__v_34)) } else { aiur::execute::bytes2_xor_value(__v_2, __v_34, record) }; let __v_131: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_3), (&__v_35)) } else { aiur::execute::bytes2_xor_value(__v_3, __v_35, record) }; let __v_132: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_4), (&__v_36)) } else { aiur::execute::bytes2_xor_value(__v_4, __v_36, record) }; let __v_133: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_5), (&__v_37)) } else { aiur::execute::bytes2_xor_value(__v_5, __v_37, record) }; let __v_134: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_6), (&__v_38)) } else { aiur::execute::bytes2_xor_value(__v_6, __v_38, record) }; let __v_135: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_7), (&__v_39)) } else { aiur::execute::bytes2_xor_value(__v_7, __v_39, record) }; let __v_136: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_8), (&__v_40)) } else { aiur::execute::bytes2_xor_value(__v_8, __v_40, record) }; let __v_137: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_9), (&__v_41)) } else { aiur::execute::bytes2_xor_value(__v_9, __v_41, record) }; let __v_138: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_10), (&__v_42)) } else { aiur::execute::bytes2_xor_value(__v_10, __v_42, record) }; let __v_139: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_11), (&__v_43)) } else { aiur::execute::bytes2_xor_value(__v_11, __v_43, record) }; let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_12), (&__v_44)) } else { aiur::execute::bytes2_xor_value(__v_12, __v_44, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_13), (&__v_45)) } else { aiur::execute::bytes2_xor_value(__v_13, __v_45, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_14), (&__v_46)) } else { aiur::execute::bytes2_xor_value(__v_14, __v_46, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_15), (&__v_47)) } else { aiur::execute::bytes2_xor_value(__v_15, __v_47, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_16), (&__v_48)) } else { aiur::execute::bytes2_xor_value(__v_16, __v_48, record) }; let __v_145: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_17), (&__v_49)) } else { aiur::execute::bytes2_xor_value(__v_17, __v_49, record) }; let __v_146: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_18), (&__v_50)) } else { aiur::execute::bytes2_xor_value(__v_18, __v_50, record) }; let __v_147: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_19), (&__v_51)) } else { aiur::execute::bytes2_xor_value(__v_19, __v_51, record) }; let __v_148: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_20), (&__v_52)) } else { aiur::execute::bytes2_xor_value(__v_20, __v_52, record) }; let __v_149: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_21), (&__v_53)) } else { aiur::execute::bytes2_xor_value(__v_21, __v_53, record) }; let __v_150: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_22), (&__v_54)) } else { aiur::execute::bytes2_xor_value(__v_22, __v_54, record) }; let __v_151: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_23), (&__v_55)) } else { aiur::execute::bytes2_xor_value(__v_23, __v_55, record) }; let __v_152: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_24), (&__v_56)) } else { aiur::execute::bytes2_xor_value(__v_24, __v_56, record) }; let __v_153: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_25), (&__v_57)) } else { aiur::execute::bytes2_xor_value(__v_25, __v_57, record) }; let __v_154: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_26), (&__v_58)) } else { aiur::execute::bytes2_xor_value(__v_26, __v_58, record) }; let __v_155: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_27), (&__v_59)) } else { aiur::execute::bytes2_xor_value(__v_27, __v_59, record) }; let __v_156: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_28), (&__v_60)) } else { aiur::execute::bytes2_xor_value(__v_28, __v_60, record) }; let __v_157: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_29), (&__v_61)) } else { aiur::execute::bytes2_xor_value(__v_29, __v_61, record) }; let __v_158: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_30), (&__v_62)) } else { aiur::execute::bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_31), (&__v_63)) } else { aiur::execute::bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_32), (&__v_64)) } else { aiur::execute::bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_83] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = ((u128::from(((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24))) + u128::from(((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24)))) + u128::from(((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); let __v_137: G = (__v_133 - __v_136); let __v_138: G = (__v_135 * __v_137); let __v_139: G = (__v_133 * __v_138); let __v_140: G = G::from_u64(0); if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_49), (&__v_129)) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_50), (&__v_130)) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_51), (&__v_131)) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_52), (&__v_132)) } else { aiur::execute::bytes2_xor_value(__v_52, __v_132, record) }; let __u32_sum: u128 = (u128::from(((((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8)) | (__v_35.as_canonical_u64() << 16)) | (__v_36.as_canonical_u64() << 24))) + u128::from(((((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8)) | (__v_141.as_canonical_u64() << 16)) | (__v_142.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); let __v_146: G = G::from_u8(__u32_bytes[1]); let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_17), (&__v_145)) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_18), (&__v_146)) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_19), (&__v_147)) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_20), (&__v_148)) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_148, record) }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); let __v_160: G = (__v_155 + __v_158); let __v_161: G = (__v_157 + __v_152); let __v_162: G = (__v_151 + __v_154); let __u32_sum: u128 = ((u128::from(((((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8)) | (__v_131.as_canonical_u64() << 16)) | (__v_132.as_canonical_u64() << 24))) + u128::from(((((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8)) | (__v_161.as_canonical_u64() << 16)) | (__v_162.as_canonical_u64() << 24)))) + u128::from(((((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8)) | (__v_71.as_canonical_u64() << 16)) | (__v_72.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_163: G = G::from_u8(__u32_bytes[0]); let __v_164: G = G::from_u8(__u32_bytes[1]); let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_168: G = (__v_167 - __v_134); let __v_169: G = (__v_167 - __v_136); let __v_170: G = (__v_168 * __v_169); let __v_171: G = (__v_167 * __v_170); if (__v_171 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_143), (&__v_163)) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_144), (&__v_164)) } else { aiur::execute::bytes2_xor_value(__v_144, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_141), (&__v_165)) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __v_175: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_142), (&__v_166)) } else { aiur::execute::bytes2_xor_value(__v_142, __v_166, record) }; let __u32_sum: u128 = (u128::from(((((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8)) | (__v_147.as_canonical_u64() << 16)) | (__v_148.as_canonical_u64() << 24))) + u128::from(((((__v_173.as_canonical_u64() << 0) | (__v_174.as_canonical_u64() << 8)) | (__v_175.as_canonical_u64() << 16)) | (__v_172.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_176: G = G::from_u8(__u32_bytes[0]); let __v_177: G = G::from_u8(__u32_bytes[1]); let __v_178: G = G::from_u8(__u32_bytes[2]); let __v_179: G = G::from_u8(__u32_bytes[3]); let __v_180: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_176; let __vj = __v_177; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_181: G = (__v_180 * __v_180); if (__v_181 != __v_180) { return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_180.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_159), (&__v_176)) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_182: G = __b2_out.0; let __v_183: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_160), (&__v_177)) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_161), (&__v_178)) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_162), (&__v_179)) } else { aiur::execute::bytes2_xor_split7_value(__v_162, __v_179, record) }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; let __v_190: G = (__v_182 + __v_185); let __v_191: G = (__v_184 + __v_187); let __v_192: G = (__v_186 + __v_189); let __v_193: G = (__v_188 + __v_183); let __u32_sum: u128 = ((u128::from(((((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8)) | (__v_7.as_canonical_u64() << 16)) | (__v_8.as_canonical_u64() << 24))) + u128::from(((((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8)) | (__v_23.as_canonical_u64() << 16)) | (__v_24.as_canonical_u64() << 24)))) + u128::from(((((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8)) | (__v_75.as_canonical_u64() << 16)) | (__v_76.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_194: G = G::from_u8(__u32_bytes[0]); let __v_195: G = G::from_u8(__u32_bytes[1]); let __v_196: G = G::from_u8(__u32_bytes[2]); let __v_197: G = G::from_u8(__u32_bytes[3]); let __v_198: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_194; let __vj = __v_195; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_199: G = (__v_198 - __v_134); let __v_200: G = (__v_198 - __v_136); let __v_201: G = (__v_199 * __v_200); let __v_202: G = (__v_198 * __v_201); if (__v_202 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_53), (&__v_194)) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_54), (&__v_195)) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_55), (&__v_196)) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __v_206: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_56), (&__v_197)) } else { aiur::execute::bytes2_xor_value(__v_56, __v_197, record) }; let __u32_sum: u128 = (u128::from(((((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8)) | (__v_39.as_canonical_u64() << 16)) | (__v_40.as_canonical_u64() << 24))) + u128::from(((((__v_205.as_canonical_u64() << 0) | (__v_206.as_canonical_u64() << 8)) | (__v_203.as_canonical_u64() << 16)) | (__v_204.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_207: G = G::from_u8(__u32_bytes[0]); let __v_208: G = G::from_u8(__u32_bytes[1]); let __v_209: G = G::from_u8(__u32_bytes[2]); let __v_210: G = G::from_u8(__u32_bytes[3]); let __v_211: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_207; let __vj = __v_208; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_209; let __vj = __v_210; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_212: G = (__v_211 * __v_211); if (__v_212 != __v_211) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_211.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_21), (&__v_207)) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_213: G = __b2_out.0; let __v_214: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_22), (&__v_208)) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_215: G = __b2_out.0; let __v_216: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_23), (&__v_209)) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_217: G = __b2_out.0; let __v_218: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_24), (&__v_210)) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_210, record) }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; let __v_221: G = (__v_215 + __v_218); let __v_222: G = (__v_217 + __v_220); let __v_223: G = (__v_219 + __v_214); let __v_224: G = (__v_213 + __v_216); let __u32_sum: u128 = ((u128::from(((((__v_194.as_canonical_u64() << 0) | (__v_195.as_canonical_u64() << 8)) | (__v_196.as_canonical_u64() << 16)) | (__v_197.as_canonical_u64() << 24))) + u128::from(((((__v_221.as_canonical_u64() << 0) | (__v_222.as_canonical_u64() << 8)) | (__v_223.as_canonical_u64() << 16)) | (__v_224.as_canonical_u64() << 24)))) + u128::from(((((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8)) | (__v_79.as_canonical_u64() << 16)) | (__v_80.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_225: G = G::from_u8(__u32_bytes[0]); let __v_226: G = G::from_u8(__u32_bytes[1]); let __v_227: G = G::from_u8(__u32_bytes[2]); let __v_228: G = G::from_u8(__u32_bytes[3]); let __v_229: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_225; let __vj = __v_226; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_227; let __vj = __v_228; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_230: G = (__v_229 - __v_134); let __v_231: G = (__v_229 - __v_136); let __v_232: G = (__v_230 * __v_231); let __v_233: G = (__v_229 * __v_232); if (__v_233 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_205), (&__v_225)) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_206), (&__v_226)) } else { aiur::execute::bytes2_xor_value(__v_206, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_203), (&__v_227)) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __v_237: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_204), (&__v_228)) } else { aiur::execute::bytes2_xor_value(__v_204, __v_228, record) }; let __u32_sum: u128 = (u128::from(((((__v_207.as_canonical_u64() << 0) | (__v_208.as_canonical_u64() << 8)) | (__v_209.as_canonical_u64() << 16)) | (__v_210.as_canonical_u64() << 24))) + u128::from(((((__v_235.as_canonical_u64() << 0) | (__v_236.as_canonical_u64() << 8)) | (__v_237.as_canonical_u64() << 16)) | (__v_234.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_238: G = G::from_u8(__u32_bytes[0]); let __v_239: G = G::from_u8(__u32_bytes[1]); let __v_240: G = G::from_u8(__u32_bytes[2]); let __v_241: G = G::from_u8(__u32_bytes[3]); let __v_242: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_238; let __vj = __v_239; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_240; let __vj = __v_241; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_243: G = (__v_242 * __v_242); if (__v_243 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_221), (&__v_238)) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_244: G = __b2_out.0; let __v_245: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_222), (&__v_239)) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_246: G = __b2_out.0; let __v_247: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_223), (&__v_240)) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_248: G = __b2_out.0; let __v_249: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_224), (&__v_241)) } else { aiur::execute::bytes2_xor_split7_value(__v_224, __v_241, record) }; let __v_250: G = __b2_out.0; let __v_251: G = __b2_out.1; let __v_252: G = (__v_244 + __v_247); let __v_253: G = (__v_246 + __v_249); let __v_254: G = (__v_248 + __v_251); let __v_255: G = (__v_250 + __v_245); let __u32_sum: u128 = ((u128::from(((((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8)) | (__v_11.as_canonical_u64() << 16)) | (__v_12.as_canonical_u64() << 24))) + u128::from(((((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8)) | (__v_27.as_canonical_u64() << 16)) | (__v_28.as_canonical_u64() << 24)))) + u128::from(((((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8)) | (__v_83.as_canonical_u64() << 16)) | (__v_84.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_256: G = G::from_u8(__u32_bytes[0]); let __v_257: G = G::from_u8(__u32_bytes[1]); let __v_258: G = G::from_u8(__u32_bytes[2]); let __v_259: G = G::from_u8(__u32_bytes[3]); let __v_260: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_256; let __vj = __v_257; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_258; let __vj = __v_259; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_261: G = (__v_260 - __v_134); let __v_262: G = (__v_260 - __v_136); let __v_263: G = (__v_261 * __v_262); let __v_264: G = (__v_260 * __v_263); if (__v_264 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_57), (&__v_256)) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_58), (&__v_257)) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_59), (&__v_258)) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __v_268: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_60), (&__v_259)) } else { aiur::execute::bytes2_xor_value(__v_60, __v_259, record) }; let __u32_sum: u128 = (u128::from(((((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8)) | (__v_43.as_canonical_u64() << 16)) | (__v_44.as_canonical_u64() << 24))) + u128::from(((((__v_267.as_canonical_u64() << 0) | (__v_268.as_canonical_u64() << 8)) | (__v_265.as_canonical_u64() << 16)) | (__v_266.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_269: G = G::from_u8(__u32_bytes[0]); let __v_270: G = G::from_u8(__u32_bytes[1]); let __v_271: G = G::from_u8(__u32_bytes[2]); let __v_272: G = G::from_u8(__u32_bytes[3]); let __v_273: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_269; let __vj = __v_270; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_271; let __vj = __v_272; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_274: G = (__v_273 * __v_273); if (__v_274 != __v_273) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_273.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_25), (&__v_269)) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_275: G = __b2_out.0; let __v_276: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_26), (&__v_270)) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_277: G = __b2_out.0; let __v_278: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_27), (&__v_271)) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_279: G = __b2_out.0; let __v_280: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_28), (&__v_272)) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_272, record) }; let __v_281: G = __b2_out.0; let __v_282: G = __b2_out.1; let __v_283: G = (__v_277 + __v_280); let __v_284: G = (__v_279 + __v_282); let __v_285: G = (__v_281 + __v_276); let __v_286: G = (__v_275 + __v_278); let __u32_sum: u128 = ((u128::from(((((__v_256.as_canonical_u64() << 0) | (__v_257.as_canonical_u64() << 8)) | (__v_258.as_canonical_u64() << 16)) | (__v_259.as_canonical_u64() << 24))) + u128::from(((((__v_283.as_canonical_u64() << 0) | (__v_284.as_canonical_u64() << 8)) | (__v_285.as_canonical_u64() << 16)) | (__v_286.as_canonical_u64() << 24)))) + u128::from(((((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8)) | (__v_87.as_canonical_u64() << 16)) | (__v_88.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_287: G = G::from_u8(__u32_bytes[0]); let __v_288: G = G::from_u8(__u32_bytes[1]); let __v_289: G = G::from_u8(__u32_bytes[2]); let __v_290: G = G::from_u8(__u32_bytes[3]); let __v_291: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_287; let __vj = __v_288; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_289; let __vj = __v_290; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_292: G = (__v_291 - __v_134); let __v_293: G = (__v_291 - __v_136); let __v_294: G = (__v_292 * __v_293); let __v_295: G = (__v_291 * __v_294); if (__v_295 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_295.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_267), (&__v_287)) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_268), (&__v_288)) } else { aiur::execute::bytes2_xor_value(__v_268, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_265), (&__v_289)) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __v_299: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_266), (&__v_290)) } else { aiur::execute::bytes2_xor_value(__v_266, __v_290, record) }; let __u32_sum: u128 = (u128::from(((((__v_269.as_canonical_u64() << 0) | (__v_270.as_canonical_u64() << 8)) | (__v_271.as_canonical_u64() << 16)) | (__v_272.as_canonical_u64() << 24))) + u128::from(((((__v_297.as_canonical_u64() << 0) | (__v_298.as_canonical_u64() << 8)) | (__v_299.as_canonical_u64() << 16)) | (__v_296.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_300: G = G::from_u8(__u32_bytes[0]); let __v_301: G = G::from_u8(__u32_bytes[1]); let __v_302: G = G::from_u8(__u32_bytes[2]); let __v_303: G = G::from_u8(__u32_bytes[3]); let __v_304: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_305: G = (__v_304 * __v_304); if (__v_305 != __v_304) { return Err(ExecError::AssertEqMismatch { lhs: __v_305.as_canonical_u64(), rhs: __v_304.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_283), (&__v_300)) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_306: G = __b2_out.0; let __v_307: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_284), (&__v_301)) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_308: G = __b2_out.0; let __v_309: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_285), (&__v_302)) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_310: G = __b2_out.0; let __v_311: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_286), (&__v_303)) } else { aiur::execute::bytes2_xor_split7_value(__v_286, __v_303, record) }; let __v_312: G = __b2_out.0; let __v_313: G = __b2_out.1; let __v_314: G = (__v_306 + __v_309); let __v_315: G = (__v_308 + __v_311); let __v_316: G = (__v_310 + __v_313); let __v_317: G = (__v_312 + __v_307); let __u32_sum: u128 = ((u128::from(((((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8)) | (__v_15.as_canonical_u64() << 16)) | (__v_16.as_canonical_u64() << 24))) + u128::from(((((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8)) | (__v_31.as_canonical_u64() << 16)) | (__v_32.as_canonical_u64() << 24)))) + u128::from(((((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8)) | (__v_91.as_canonical_u64() << 16)) | (__v_92.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_318: G = G::from_u8(__u32_bytes[0]); let __v_319: G = G::from_u8(__u32_bytes[1]); let __v_320: G = G::from_u8(__u32_bytes[2]); let __v_321: G = G::from_u8(__u32_bytes[3]); let __v_322: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_318; let __vj = __v_319; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_320; let __vj = __v_321; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_323: G = (__v_322 - __v_134); let __v_324: G = (__v_322 - __v_136); let __v_325: G = (__v_323 * __v_324); let __v_326: G = (__v_322 * __v_325); if (__v_326 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_61), (&__v_318)) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_62), (&__v_319)) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_63), (&__v_320)) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __v_330: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_64), (&__v_321)) } else { aiur::execute::bytes2_xor_value(__v_64, __v_321, record) }; let __u32_sum: u128 = (u128::from(((((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8)) | (__v_47.as_canonical_u64() << 16)) | (__v_48.as_canonical_u64() << 24))) + u128::from(((((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8)) | (__v_327.as_canonical_u64() << 16)) | (__v_328.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_331: G = G::from_u8(__u32_bytes[0]); let __v_332: G = G::from_u8(__u32_bytes[1]); let __v_333: G = G::from_u8(__u32_bytes[2]); let __v_334: G = G::from_u8(__u32_bytes[3]); let __v_335: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_331; let __vj = __v_332; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_336: G = (__v_335 * __v_335); if (__v_336 != __v_335) { return Err(ExecError::AssertEqMismatch { lhs: __v_336.as_canonical_u64(), rhs: __v_335.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_29), (&__v_331)) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_337: G = __b2_out.0; let __v_338: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_30), (&__v_332)) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_339: G = __b2_out.0; let __v_340: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_31), (&__v_333)) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_341: G = __b2_out.0; let __v_342: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_32), (&__v_334)) } else { aiur::execute::bytes2_xor_split4_value(__v_32, __v_334, record) }; let __v_343: G = __b2_out.0; let __v_344: G = __b2_out.1; let __v_345: G = (__v_339 + __v_342); let __v_346: G = (__v_341 + __v_344); let __v_347: G = (__v_343 + __v_338); let __v_348: G = (__v_337 + __v_340); let __u32_sum: u128 = ((u128::from(((((__v_318.as_canonical_u64() << 0) | (__v_319.as_canonical_u64() << 8)) | (__v_320.as_canonical_u64() << 16)) | (__v_321.as_canonical_u64() << 24))) + u128::from(((((__v_345.as_canonical_u64() << 0) | (__v_346.as_canonical_u64() << 8)) | (__v_347.as_canonical_u64() << 16)) | (__v_348.as_canonical_u64() << 24)))) + u128::from(((((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8)) | (__v_95.as_canonical_u64() << 16)) | (__v_96.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); let __v_350: G = G::from_u8(__u32_bytes[1]); let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_354: G = (__v_353 - __v_134); let __v_355: G = (__v_353 - __v_136); let __v_356: G = (__v_354 * __v_355); let __v_357: G = (__v_353 * __v_356); if (__v_357 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_329), (&__v_349)) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_330), (&__v_350)) } else { aiur::execute::bytes2_xor_value(__v_330, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_327), (&__v_351)) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __v_361: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_328), (&__v_352)) } else { aiur::execute::bytes2_xor_value(__v_328, __v_352, record) }; let __u32_sum: u128 = (u128::from(((((__v_331.as_canonical_u64() << 0) | (__v_332.as_canonical_u64() << 8)) | (__v_333.as_canonical_u64() << 16)) | (__v_334.as_canonical_u64() << 24))) + u128::from(((((__v_359.as_canonical_u64() << 0) | (__v_360.as_canonical_u64() << 8)) | (__v_361.as_canonical_u64() << 16)) | (__v_358.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_362: G = G::from_u8(__u32_bytes[0]); let __v_363: G = G::from_u8(__u32_bytes[1]); let __v_364: G = G::from_u8(__u32_bytes[2]); let __v_365: G = G::from_u8(__u32_bytes[3]); let __v_366: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_362; let __vj = __v_363; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_364; let __vj = __v_365; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_367: G = (__v_366 * __v_366); if (__v_367 != __v_366) { return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_366.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_345), (&__v_362)) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_368: G = __b2_out.0; let __v_369: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_346), (&__v_363)) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_370: G = __b2_out.0; let __v_371: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_347), (&__v_364)) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_372: G = __b2_out.0; let __v_373: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_348), (&__v_365)) } else { aiur::execute::bytes2_xor_split7_value(__v_348, __v_365, record) }; let __v_374: G = __b2_out.0; let __v_375: G = __b2_out.1; let __v_376: G = (__v_368 + __v_371); let __v_377: G = (__v_370 + __v_373); let __v_378: G = (__v_372 + __v_375); let __v_379: G = (__v_374 + __v_369); let __u32_sum: u128 = ((u128::from(((((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8)) | (__v_165.as_canonical_u64() << 16)) | (__v_166.as_canonical_u64() << 24))) + u128::from(((((__v_252.as_canonical_u64() << 0) | (__v_253.as_canonical_u64() << 8)) | (__v_254.as_canonical_u64() << 16)) | (__v_255.as_canonical_u64() << 24)))) + u128::from(((((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8)) | (__v_99.as_canonical_u64() << 16)) | (__v_100.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_380: G = G::from_u8(__u32_bytes[0]); let __v_381: G = G::from_u8(__u32_bytes[1]); let __v_382: G = G::from_u8(__u32_bytes[2]); let __v_383: G = G::from_u8(__u32_bytes[3]); let __v_384: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_380; let __vj = __v_381; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_385: G = (__v_384 - __v_134); let __v_386: G = (__v_384 - __v_136); let __v_387: G = (__v_385 * __v_386); let __v_388: G = (__v_384 * __v_387); if (__v_388 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_359), (&__v_380)) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_360), (&__v_381)) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_361), (&__v_382)) } else { aiur::execute::bytes2_xor_value(__v_361, __v_382, record) }; let __v_392: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_358), (&__v_383)) } else { aiur::execute::bytes2_xor_value(__v_358, __v_383, record) }; let __u32_sum: u128 = (u128::from(((((__v_300.as_canonical_u64() << 0) | (__v_301.as_canonical_u64() << 8)) | (__v_302.as_canonical_u64() << 16)) | (__v_303.as_canonical_u64() << 24))) + u128::from(((((__v_391.as_canonical_u64() << 0) | (__v_392.as_canonical_u64() << 8)) | (__v_389.as_canonical_u64() << 16)) | (__v_390.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_393: G = G::from_u8(__u32_bytes[0]); let __v_394: G = G::from_u8(__u32_bytes[1]); let __v_395: G = G::from_u8(__u32_bytes[2]); let __v_396: G = G::from_u8(__u32_bytes[3]); let __v_397: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_393; let __vj = __v_394; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_395; let __vj = __v_396; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_398: G = (__v_397 * __v_397); if (__v_398 != __v_397) { return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_397.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_252), (&__v_393)) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_399: G = __b2_out.0; let __v_400: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_253), (&__v_394)) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_401: G = __b2_out.0; let __v_402: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_254), (&__v_395)) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_403: G = __b2_out.0; let __v_404: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_255), (&__v_396)) } else { aiur::execute::bytes2_xor_split4_value(__v_255, __v_396, record) }; let __v_405: G = __b2_out.0; let __v_406: G = __b2_out.1; let __v_407: G = (__v_401 + __v_404); let __v_408: G = (__v_403 + __v_406); let __v_409: G = (__v_405 + __v_400); let __v_410: G = (__v_399 + __v_402); let __u32_sum: u128 = ((u128::from(((((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8)) | (__v_382.as_canonical_u64() << 16)) | (__v_383.as_canonical_u64() << 24))) + u128::from(((((__v_407.as_canonical_u64() << 0) | (__v_408.as_canonical_u64() << 8)) | (__v_409.as_canonical_u64() << 16)) | (__v_410.as_canonical_u64() << 24)))) + u128::from(((((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8)) | (__v_103.as_canonical_u64() << 16)) | (__v_104.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_411: G = G::from_u8(__u32_bytes[0]); let __v_412: G = G::from_u8(__u32_bytes[1]); let __v_413: G = G::from_u8(__u32_bytes[2]); let __v_414: G = G::from_u8(__u32_bytes[3]); let __v_415: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_411; let __vj = __v_412; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_413; let __vj = __v_414; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_416: G = (__v_415 - __v_134); let __v_417: G = (__v_415 - __v_136); let __v_418: G = (__v_416 * __v_417); let __v_419: G = (__v_415 * __v_418); if (__v_419 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_391), (&__v_411)) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_392), (&__v_412)) } else { aiur::execute::bytes2_xor_value(__v_392, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_389), (&__v_413)) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __v_423: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_390), (&__v_414)) } else { aiur::execute::bytes2_xor_value(__v_390, __v_414, record) }; let __u32_sum: u128 = (u128::from(((((__v_393.as_canonical_u64() << 0) | (__v_394.as_canonical_u64() << 8)) | (__v_395.as_canonical_u64() << 16)) | (__v_396.as_canonical_u64() << 24))) + u128::from(((((__v_421.as_canonical_u64() << 0) | (__v_422.as_canonical_u64() << 8)) | (__v_423.as_canonical_u64() << 16)) | (__v_420.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_424: G = G::from_u8(__u32_bytes[0]); let __v_425: G = G::from_u8(__u32_bytes[1]); let __v_426: G = G::from_u8(__u32_bytes[2]); let __v_427: G = G::from_u8(__u32_bytes[3]); let __v_428: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_424; let __vj = __v_425; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_426; let __vj = __v_427; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_429: G = (__v_428 * __v_428); if (__v_429 != __v_428) { return Err(ExecError::AssertEqMismatch { lhs: __v_429.as_canonical_u64(), rhs: __v_428.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_407), (&__v_424)) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_430: G = __b2_out.0; let __v_431: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_408), (&__v_425)) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_432: G = __b2_out.0; let __v_433: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_409), (&__v_426)) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_434: G = __b2_out.0; let __v_435: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_410), (&__v_427)) } else { aiur::execute::bytes2_xor_split7_value(__v_410, __v_427, record) }; let __v_436: G = __b2_out.0; let __v_437: G = __b2_out.1; let __v_438: G = (__v_430 + __v_433); let __v_439: G = (__v_432 + __v_435); let __v_440: G = (__v_434 + __v_437); let __v_441: G = (__v_436 + __v_431); let __u32_sum: u128 = ((u128::from(((((__v_225.as_canonical_u64() << 0) | (__v_226.as_canonical_u64() << 8)) | (__v_227.as_canonical_u64() << 16)) | (__v_228.as_canonical_u64() << 24))) + u128::from(((((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8)) | (__v_316.as_canonical_u64() << 16)) | (__v_317.as_canonical_u64() << 24)))) + u128::from(((((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8)) | (__v_107.as_canonical_u64() << 16)) | (__v_108.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_442: G = G::from_u8(__u32_bytes[0]); let __v_443: G = G::from_u8(__u32_bytes[1]); let __v_444: G = G::from_u8(__u32_bytes[2]); let __v_445: G = G::from_u8(__u32_bytes[3]); let __v_446: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_442; let __vj = __v_443; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_444; let __vj = __v_445; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_447: G = (__v_446 - __v_134); let __v_448: G = (__v_446 - __v_136); let __v_449: G = (__v_447 * __v_448); let __v_450: G = (__v_446 * __v_449); if (__v_450 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_450.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_173), (&__v_442)) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_174), (&__v_443)) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_175), (&__v_444)) } else { aiur::execute::bytes2_xor_value(__v_175, __v_444, record) }; let __v_454: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_172), (&__v_445)) } else { aiur::execute::bytes2_xor_value(__v_172, __v_445, record) }; let __u32_sum: u128 = (u128::from(((((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8)) | (__v_364.as_canonical_u64() << 16)) | (__v_365.as_canonical_u64() << 24))) + u128::from(((((__v_453.as_canonical_u64() << 0) | (__v_454.as_canonical_u64() << 8)) | (__v_451.as_canonical_u64() << 16)) | (__v_452.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_455: G = G::from_u8(__u32_bytes[0]); let __v_456: G = G::from_u8(__u32_bytes[1]); let __v_457: G = G::from_u8(__u32_bytes[2]); let __v_458: G = G::from_u8(__u32_bytes[3]); let __v_459: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_455; let __vj = __v_456; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_457; let __vj = __v_458; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_460: G = (__v_459 * __v_459); if (__v_460 != __v_459) { return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_314), (&__v_455)) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_315), (&__v_456)) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_316), (&__v_457)) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_465: G = __b2_out.0; let __v_466: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_317), (&__v_458)) } else { aiur::execute::bytes2_xor_split4_value(__v_317, __v_458, record) }; let __v_467: G = __b2_out.0; let __v_468: G = __b2_out.1; let __v_469: G = (__v_463 + __v_466); let __v_470: G = (__v_465 + __v_468); let __v_471: G = (__v_467 + __v_462); let __v_472: G = (__v_461 + __v_464); let __u32_sum: u128 = ((u128::from(((((__v_442.as_canonical_u64() << 0) | (__v_443.as_canonical_u64() << 8)) | (__v_444.as_canonical_u64() << 16)) | (__v_445.as_canonical_u64() << 24))) + u128::from(((((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8)) | (__v_471.as_canonical_u64() << 16)) | (__v_472.as_canonical_u64() << 24)))) + u128::from(((((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8)) | (__v_111.as_canonical_u64() << 16)) | (__v_112.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_473: G = G::from_u8(__u32_bytes[0]); let __v_474: G = G::from_u8(__u32_bytes[1]); let __v_475: G = G::from_u8(__u32_bytes[2]); let __v_476: G = G::from_u8(__u32_bytes[3]); let __v_477: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_473; let __vj = __v_474; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_475; let __vj = __v_476; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_478: G = (__v_477 - __v_134); let __v_479: G = (__v_477 - __v_136); let __v_480: G = (__v_478 * __v_479); let __v_481: G = (__v_477 * __v_480); if (__v_481 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_453), (&__v_473)) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_454), (&__v_474)) } else { aiur::execute::bytes2_xor_value(__v_454, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_451), (&__v_475)) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __v_485: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_452), (&__v_476)) } else { aiur::execute::bytes2_xor_value(__v_452, __v_476, record) }; let __u32_sum: u128 = (u128::from(((((__v_455.as_canonical_u64() << 0) | (__v_456.as_canonical_u64() << 8)) | (__v_457.as_canonical_u64() << 16)) | (__v_458.as_canonical_u64() << 24))) + u128::from(((((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8)) | (__v_485.as_canonical_u64() << 16)) | (__v_482.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_486: G = G::from_u8(__u32_bytes[0]); let __v_487: G = G::from_u8(__u32_bytes[1]); let __v_488: G = G::from_u8(__u32_bytes[2]); let __v_489: G = G::from_u8(__u32_bytes[3]); let __v_490: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_488; let __vj = __v_489; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_491: G = (__v_490 * __v_490); if (__v_491 != __v_490) { return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_469), (&__v_486)) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_470), (&__v_487)) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_471), (&__v_488)) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_472), (&__v_489)) } else { aiur::execute::bytes2_xor_split7_value(__v_472, __v_489, record) }; let __v_498: G = __b2_out.0; let __v_499: G = __b2_out.1; let __v_500: G = (__v_492 + __v_495); let __v_501: G = (__v_494 + __v_497); let __v_502: G = (__v_496 + __v_499); let __v_503: G = (__v_498 + __v_493); let __u32_sum: u128 = ((u128::from(((((__v_287.as_canonical_u64() << 0) | (__v_288.as_canonical_u64() << 8)) | (__v_289.as_canonical_u64() << 16)) | (__v_290.as_canonical_u64() << 24))) + u128::from(((((__v_376.as_canonical_u64() << 0) | (__v_377.as_canonical_u64() << 8)) | (__v_378.as_canonical_u64() << 16)) | (__v_379.as_canonical_u64() << 24)))) + u128::from(((((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8)) | (__v_115.as_canonical_u64() << 16)) | (__v_116.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_504: G = G::from_u8(__u32_bytes[0]); let __v_505: G = G::from_u8(__u32_bytes[1]); let __v_506: G = G::from_u8(__u32_bytes[2]); let __v_507: G = G::from_u8(__u32_bytes[3]); let __v_508: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_506; let __vj = __v_507; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_509: G = (__v_508 - __v_134); let __v_510: G = (__v_508 - __v_136); let __v_511: G = (__v_509 * __v_510); let __v_512: G = (__v_508 * __v_511); if (__v_512 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_235), (&__v_504)) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_236), (&__v_505)) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_237), (&__v_506)) } else { aiur::execute::bytes2_xor_value(__v_237, __v_506, record) }; let __v_516: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_234), (&__v_507)) } else { aiur::execute::bytes2_xor_value(__v_234, __v_507, record) }; let __u32_sum: u128 = (u128::from(((((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8)) | (__v_178.as_canonical_u64() << 16)) | (__v_179.as_canonical_u64() << 24))) + u128::from(((((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8)) | (__v_513.as_canonical_u64() << 16)) | (__v_514.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_517: G = G::from_u8(__u32_bytes[0]); let __v_518: G = G::from_u8(__u32_bytes[1]); let __v_519: G = G::from_u8(__u32_bytes[2]); let __v_520: G = G::from_u8(__u32_bytes[3]); let __v_521: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_517; let __vj = __v_518; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_522: G = (__v_521 * __v_521); if (__v_522 != __v_521) { return Err(ExecError::AssertEqMismatch { lhs: __v_522.as_canonical_u64(), rhs: __v_521.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_376), (&__v_517)) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_523: G = __b2_out.0; let __v_524: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_377), (&__v_518)) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_378), (&__v_519)) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_379), (&__v_520)) } else { aiur::execute::bytes2_xor_split4_value(__v_379, __v_520, record) }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; let __v_531: G = (__v_525 + __v_528); let __v_532: G = (__v_527 + __v_530); let __v_533: G = (__v_529 + __v_524); let __v_534: G = (__v_523 + __v_526); let __u32_sum: u128 = ((u128::from(((((__v_504.as_canonical_u64() << 0) | (__v_505.as_canonical_u64() << 8)) | (__v_506.as_canonical_u64() << 16)) | (__v_507.as_canonical_u64() << 24))) + u128::from(((((__v_531.as_canonical_u64() << 0) | (__v_532.as_canonical_u64() << 8)) | (__v_533.as_canonical_u64() << 16)) | (__v_534.as_canonical_u64() << 24)))) + u128::from(((((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8)) | (__v_119.as_canonical_u64() << 16)) | (__v_120.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_535: G = G::from_u8(__u32_bytes[0]); let __v_536: G = G::from_u8(__u32_bytes[1]); let __v_537: G = G::from_u8(__u32_bytes[2]); let __v_538: G = G::from_u8(__u32_bytes[3]); let __v_539: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_535; let __vj = __v_536; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_540: G = (__v_539 - __v_134); let __v_541: G = (__v_539 - __v_136); let __v_542: G = (__v_540 * __v_541); let __v_543: G = (__v_539 * __v_542); if (__v_543 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_515), (&__v_535)) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_516), (&__v_536)) } else { aiur::execute::bytes2_xor_value(__v_516, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_513), (&__v_537)) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __v_547: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_514), (&__v_538)) } else { aiur::execute::bytes2_xor_value(__v_514, __v_538, record) }; let __u32_sum: u128 = (u128::from(((((__v_517.as_canonical_u64() << 0) | (__v_518.as_canonical_u64() << 8)) | (__v_519.as_canonical_u64() << 16)) | (__v_520.as_canonical_u64() << 24))) + u128::from(((((__v_545.as_canonical_u64() << 0) | (__v_546.as_canonical_u64() << 8)) | (__v_547.as_canonical_u64() << 16)) | (__v_544.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_548: G = G::from_u8(__u32_bytes[0]); let __v_549: G = G::from_u8(__u32_bytes[1]); let __v_550: G = G::from_u8(__u32_bytes[2]); let __v_551: G = G::from_u8(__u32_bytes[3]); let __v_552: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_548; let __vj = __v_549; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_550; let __vj = __v_551; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_553: G = (__v_552 * __v_552); if (__v_553 != __v_552) { return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_552.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_531), (&__v_548)) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_554: G = __b2_out.0; let __v_555: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_532), (&__v_549)) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_556: G = __b2_out.0; let __v_557: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_533), (&__v_550)) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_534), (&__v_551)) } else { aiur::execute::bytes2_xor_split7_value(__v_534, __v_551, record) }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; let __v_562: G = (__v_554 + __v_557); let __v_563: G = (__v_556 + __v_559); let __v_564: G = (__v_558 + __v_561); let __v_565: G = (__v_560 + __v_555); let __u32_sum: u128 = ((u128::from(((((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8)) | (__v_351.as_canonical_u64() << 16)) | (__v_352.as_canonical_u64() << 24))) + u128::from(((((__v_190.as_canonical_u64() << 0) | (__v_191.as_canonical_u64() << 8)) | (__v_192.as_canonical_u64() << 16)) | (__v_193.as_canonical_u64() << 24)))) + u128::from(((((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8)) | (__v_123.as_canonical_u64() << 16)) | (__v_124.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_566: G = G::from_u8(__u32_bytes[0]); let __v_567: G = G::from_u8(__u32_bytes[1]); let __v_568: G = G::from_u8(__u32_bytes[2]); let __v_569: G = G::from_u8(__u32_bytes[3]); let __v_570: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_566; let __vj = __v_567; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_568; let __vj = __v_569; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_571: G = (__v_570 - __v_134); let __v_572: G = (__v_570 - __v_136); let __v_573: G = (__v_571 * __v_572); let __v_574: G = (__v_570 * __v_573); if (__v_574 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_574.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_297), (&__v_566)) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_298), (&__v_567)) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_299), (&__v_568)) } else { aiur::execute::bytes2_xor_value(__v_299, __v_568, record) }; let __v_578: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_296), (&__v_569)) } else { aiur::execute::bytes2_xor_value(__v_296, __v_569, record) }; let __u32_sum: u128 = (u128::from(((((__v_238.as_canonical_u64() << 0) | (__v_239.as_canonical_u64() << 8)) | (__v_240.as_canonical_u64() << 16)) | (__v_241.as_canonical_u64() << 24))) + u128::from(((((__v_577.as_canonical_u64() << 0) | (__v_578.as_canonical_u64() << 8)) | (__v_575.as_canonical_u64() << 16)) | (__v_576.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_579: G = G::from_u8(__u32_bytes[0]); let __v_580: G = G::from_u8(__u32_bytes[1]); let __v_581: G = G::from_u8(__u32_bytes[2]); let __v_582: G = G::from_u8(__u32_bytes[3]); let __v_583: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_579; let __vj = __v_580; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_581; let __vj = __v_582; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_584: G = (__v_583 * __v_583); if (__v_584 != __v_583) { return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_583.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_190), (&__v_579)) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_585: G = __b2_out.0; let __v_586: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_191), (&__v_580)) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_587: G = __b2_out.0; let __v_588: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_192), (&__v_581)) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_589: G = __b2_out.0; let __v_590: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4((&__v_193), (&__v_582)) } else { aiur::execute::bytes2_xor_split4_value(__v_193, __v_582, record) }; let __v_591: G = __b2_out.0; let __v_592: G = __b2_out.1; let __v_593: G = (__v_587 + __v_590); let __v_594: G = (__v_589 + __v_592); let __v_595: G = (__v_591 + __v_586); let __v_596: G = (__v_585 + __v_588); let __u32_sum: u128 = ((u128::from(((((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8)) | (__v_568.as_canonical_u64() << 16)) | (__v_569.as_canonical_u64() << 24))) + u128::from(((((__v_593.as_canonical_u64() << 0) | (__v_594.as_canonical_u64() << 8)) | (__v_595.as_canonical_u64() << 16)) | (__v_596.as_canonical_u64() << 24)))) + u128::from(((((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8)) | (__v_127.as_canonical_u64() << 16)) | (__v_128.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_597: G = G::from_u8(__u32_bytes[0]); let __v_598: G = G::from_u8(__u32_bytes[1]); let __v_599: G = G::from_u8(__u32_bytes[2]); let __v_600: G = G::from_u8(__u32_bytes[3]); let __v_601: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_597; let __vj = __v_598; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_599; let __vj = __v_600; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_602: G = (__v_601 - __v_134); let __v_603: G = (__v_601 - __v_136); let __v_604: G = (__v_602 * __v_603); let __v_605: G = (__v_601 * __v_604); if (__v_605 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_605.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_577), (&__v_597)) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_578), (&__v_598)) } else { aiur::execute::bytes2_xor_value(__v_578, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_575), (&__v_599)) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __v_609: G = if unconstrained { aiur::execute::CodegenBytes2::xor((&__v_576), (&__v_600)) } else { aiur::execute::bytes2_xor_value(__v_576, __v_600, record) }; let __u32_sum: u128 = (u128::from(((((__v_579.as_canonical_u64() << 0) | (__v_580.as_canonical_u64() << 8)) | (__v_581.as_canonical_u64() << 16)) | (__v_582.as_canonical_u64() << 24))) + u128::from(((((__v_607.as_canonical_u64() << 0) | (__v_608.as_canonical_u64() << 8)) | (__v_609.as_canonical_u64() << 16)) | (__v_606.as_canonical_u64() << 24)))); let __u32_bytes = u32::try_from((__u32_sum & 4294967295)).expect("masked").to_le_bytes(); let __v_610: G = G::from_u8(__u32_bytes[0]); let __v_611: G = G::from_u8(__u32_bytes[1]); let __v_612: G = G::from_u8(__u32_bytes[2]); let __v_613: G = G::from_u8(__u32_bytes[3]); let __v_614: G = G::from_u64(u64::try_from((__u32_sum >> 32)).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_610; let __vj = __v_611; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_612; let __vj = __v_613; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_615: G = (__v_614 * __v_614); if (__v_615 != __v_614) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_614.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_593), (&__v_610)) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_616: G = __b2_out.0; let __v_617: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_594), (&__v_611)) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_618: G = __b2_out.0; let __v_619: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_595), (&__v_612)) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_620: G = __b2_out.0; let __v_621: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7((&__v_596), (&__v_613)) } else { aiur::execute::bytes2_xor_split7_value(__v_596, __v_613, record) }; let __v_622: G = __b2_out.0; let __v_623: G = __b2_out.1; let __v_624: G = (__v_616 + __v_619); let __v_625: G = (__v_618 + __v_621); let __v_626: G = (__v_620 + __v_623); let __v_627: G = (__v_622 + __v_617); let __v_628: G = (__v_0 + __v_134); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_628, __v_411, __v_412, __v_413, __v_414, __v_473, __v_474, __v_475, __v_476, __v_535, __v_536, __v_537, __v_538, __v_597, __v_598, __v_599, __v_600, __v_624, __v_625, __v_626, __v_627, __v_438, __v_439, __v_440, __v_441, __v_500, __v_501, __v_502, __v_503, __v_562, __v_563, __v_564, __v_565, __v_548, __v_549, __v_550, __v_551, __v_610, __v_611, __v_612, __v_613, __v_424, __v_425, __v_426, __v_427, __v_486, __v_487, __v_488, __v_489, __v_483, __v_484, __v_485, __v_482, __v_545, __v_546, __v_547, __v_544, __v_607, __v_608, __v_609, __v_606, __v_421, __v_422, __v_423, __v_420, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_629: G = __r_arr[0]; let __v_630: G = __r_arr[1]; let __v_631: G = __r_arr[2]; let __v_632: G = __r_arr[3]; let __v_633: G = __r_arr[4]; let __v_634: G = __r_arr[5]; let __v_635: G = __r_arr[6]; let __v_636: G = __r_arr[7]; let __v_637: G = __r_arr[8]; let __v_638: G = __r_arr[9]; let __v_639: G = __r_arr[10]; let __v_640: G = __r_arr[11]; let __v_641: G = __r_arr[12]; let __v_642: G = __r_arr[13]; let __v_643: G = __r_arr[14]; let __v_644: G = __r_arr[15]; let __v_645: G = __r_arr[16]; let __v_646: G = __r_arr[17]; let __v_647: G = __r_arr[18]; let __v_648: G = __r_arr[19]; let __v_649: G = __r_arr[20]; let __v_650: G = __r_arr[21]; let __v_651: G = __r_arr[22]; let __v_652: G = __r_arr[23]; let __v_653: G = __r_arr[24]; let __v_654: G = __r_arr[25]; let __v_655: G = __r_arr[26]; let __v_656: G = __r_arr[27]; let __v_657: G = __r_arr[28]; let __v_658: G = __r_arr[29]; let __v_659: G = __r_arr[30]; let __v_660: G = __r_arr[31]; let __ret: [G; OUT_83] = [__v_629, __v_630, __v_631, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660]; record.function_queries[83].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_83(inp: [G; IN_83], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = inp[57]; let __v_58: G = inp[58]; let __v_59: G = inp[59]; let __v_60: G = inp[60]; let __v_61: G = inp[61]; let __v_62: G = inp[62]; let __v_63: G = inp[63]; let __v_64: G = inp[64]; let __v_65: G = inp[65]; let __v_66: G = inp[66]; let __v_67: G = inp[67]; let __v_68: G = inp[68]; let __v_69: G = inp[69]; let __v_70: G = inp[70]; let __v_71: G = inp[71]; let __v_72: G = inp[72]; let __v_73: G = inp[73]; let __v_74: G = inp[74]; let __v_75: G = inp[75]; let __v_76: G = inp[76]; let __v_77: G = inp[77]; let __v_78: G = inp[78]; let __v_79: G = inp[79]; let __v_80: G = inp[80]; let __v_81: G = inp[81]; let __v_82: G = inp[82]; let __v_83: G = inp[83]; let __v_84: G = inp[84]; let __v_85: G = inp[85]; let __v_86: G = inp[86]; let __v_87: G = inp[87]; let __v_88: G = inp[88]; let __v_89: G = inp[89]; let __v_90: G = inp[90]; let __v_91: G = inp[91]; let __v_92: G = inp[92]; let __v_93: G = inp[93]; let __v_94: G = inp[94]; let __v_95: G = inp[95]; let __v_96: G = inp[96]; let __v_97: G = inp[97]; let __v_98: G = inp[98]; let __v_99: G = inp[99]; let __v_100: G = inp[100]; let __v_101: G = inp[101]; let __v_102: G = inp[102]; let __v_103: G = inp[103]; let __v_104: G = inp[104]; let __v_105: G = inp[105]; let __v_106: G = inp[106]; let __v_107: G = inp[107]; let __v_108: G = inp[108]; let __v_109: G = inp[109]; let __v_110: G = inp[110]; let __v_111: G = inp[111]; let __v_112: G = inp[112]; let __v_113: G = inp[113]; let __v_114: G = inp[114]; let __v_115: G = inp[115]; let __v_116: G = inp[116]; let __v_117: G = inp[117]; let __v_118: G = inp[118]; let __v_119: G = inp[119]; let __v_120: G = inp[120]; let __v_121: G = inp[121]; let __v_122: G = inp[122]; let __v_123: G = inp[123]; let __v_124: G = inp[124]; let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; let __v_128: G = inp[128]; match __v_0.as_canonical_u64() { 7u64 => { let __v_129: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_33) } else { aiur::execute::bytes2_xor_value(__v_1, __v_33, record) }; let __v_130: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_34) } else { aiur::execute::bytes2_xor_value(__v_2, __v_34, record) }; let __v_131: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_35) } else { aiur::execute::bytes2_xor_value(__v_3, __v_35, record) }; let __v_132: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_4, &__v_36) } else { aiur::execute::bytes2_xor_value(__v_4, __v_36, record) }; let __v_133: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_5, &__v_37) } else { aiur::execute::bytes2_xor_value(__v_5, __v_37, record) }; let __v_134: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_6, &__v_38) } else { aiur::execute::bytes2_xor_value(__v_6, __v_38, record) }; let __v_135: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_7, &__v_39) } else { aiur::execute::bytes2_xor_value(__v_7, __v_39, record) }; let __v_136: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_8, &__v_40) } else { aiur::execute::bytes2_xor_value(__v_8, __v_40, record) }; let __v_137: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_9, &__v_41) } else { aiur::execute::bytes2_xor_value(__v_9, __v_41, record) }; let __v_138: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_10, &__v_42) } else { aiur::execute::bytes2_xor_value(__v_10, __v_42, record) }; let __v_139: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_11, &__v_43) } else { aiur::execute::bytes2_xor_value(__v_11, __v_43, record) }; let __v_140: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_12, &__v_44) } else { aiur::execute::bytes2_xor_value(__v_12, __v_44, record) }; let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_13, &__v_45) } else { aiur::execute::bytes2_xor_value(__v_13, __v_45, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_14, &__v_46) } else { aiur::execute::bytes2_xor_value(__v_14, __v_46, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_15, &__v_47) } else { aiur::execute::bytes2_xor_value(__v_15, __v_47, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_16, &__v_48) } else { aiur::execute::bytes2_xor_value(__v_16, __v_48, record) }; let __v_145: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_17, &__v_49) } else { aiur::execute::bytes2_xor_value(__v_17, __v_49, record) }; let __v_146: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_18, &__v_50) } else { aiur::execute::bytes2_xor_value(__v_18, __v_50, record) }; let __v_147: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_19, &__v_51) } else { aiur::execute::bytes2_xor_value(__v_19, __v_51, record) }; let __v_148: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_20, &__v_52) } else { aiur::execute::bytes2_xor_value(__v_20, __v_52, record) }; let __v_149: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_21, &__v_53) } else { aiur::execute::bytes2_xor_value(__v_21, __v_53, record) }; let __v_150: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_22, &__v_54) } else { aiur::execute::bytes2_xor_value(__v_22, __v_54, record) }; let __v_151: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_23, &__v_55) } else { aiur::execute::bytes2_xor_value(__v_23, __v_55, record) }; let __v_152: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_24, &__v_56) } else { aiur::execute::bytes2_xor_value(__v_24, __v_56, record) }; let __v_153: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_25, &__v_57) } else { aiur::execute::bytes2_xor_value(__v_25, __v_57, record) }; let __v_154: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_26, &__v_58) } else { aiur::execute::bytes2_xor_value(__v_26, __v_58, record) }; let __v_155: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_27, &__v_59) } else { aiur::execute::bytes2_xor_value(__v_27, __v_59, record) }; let __v_156: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_28, &__v_60) } else { aiur::execute::bytes2_xor_value(__v_28, __v_60, record) }; let __v_157: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_29, &__v_61) } else { aiur::execute::bytes2_xor_value(__v_29, __v_61, record) }; let __v_158: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_30, &__v_62) } else { aiur::execute::bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_31, &__v_63) } else { aiur::execute::bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_32, &__v_64) } else { aiur::execute::bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_83] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __u32_sum: u128 = (u128::from((((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8)) | (__v_3.as_canonical_u64() << 16)) | (__v_4.as_canonical_u64() << 24)) + u128::from((((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8)) | (__v_19.as_canonical_u64() << 16)) | (__v_20.as_canonical_u64() << 24))) + u128::from((((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8)) | (__v_67.as_canonical_u64() << 16)) | (__v_68.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_129: G = G::from_u8(__u32_bytes[0]); let __v_130: G = G::from_u8(__u32_bytes[1]); let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_134: G = G::from_u64(1); let __v_135: G = __v_133 - __v_134; let __v_136: G = G::from_u64(2); let __v_137: G = __v_133 - __v_136; let __v_138: G = __v_135 * __v_137; let __v_139: G = __v_133 * __v_138; let __v_140: G = G::from_u64(0); if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_141: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_49, &__v_129) } else { aiur::execute::bytes2_xor_value(__v_49, __v_129, record) }; let __v_142: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_50, &__v_130) } else { aiur::execute::bytes2_xor_value(__v_50, __v_130, record) }; let __v_143: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_51, &__v_131) } else { aiur::execute::bytes2_xor_value(__v_51, __v_131, record) }; let __v_144: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_52, &__v_132) } else { aiur::execute::bytes2_xor_value(__v_52, __v_132, record) }; let __u32_sum: u128 = u128::from((((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8)) | (__v_35.as_canonical_u64() << 16)) | (__v_36.as_canonical_u64() << 24)) + u128::from((((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8)) | (__v_141.as_canonical_u64() << 16)) | (__v_142.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); let __v_146: G = G::from_u8(__u32_bytes[1]); let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_150: G = __v_149 * __v_149; if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_17, &__v_145) } else { aiur::execute::bytes2_xor_split4_value(__v_17, __v_145, record) }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_18, &__v_146) } else { aiur::execute::bytes2_xor_split4_value(__v_18, __v_146, record) }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_19, &__v_147) } else { aiur::execute::bytes2_xor_split4_value(__v_19, __v_147, record) }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_20, &__v_148) } else { aiur::execute::bytes2_xor_split4_value(__v_20, __v_148, record) }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = __v_153 + __v_156; let __v_160: G = __v_155 + __v_158; let __v_161: G = __v_157 + __v_152; let __v_162: G = __v_151 + __v_154; let __u32_sum: u128 = (u128::from((((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8)) | (__v_131.as_canonical_u64() << 16)) | (__v_132.as_canonical_u64() << 24)) + u128::from((((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8)) | (__v_161.as_canonical_u64() << 16)) | (__v_162.as_canonical_u64() << 24))) + u128::from((((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8)) | (__v_71.as_canonical_u64() << 16)) | (__v_72.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_163: G = G::from_u8(__u32_bytes[0]); let __v_164: G = G::from_u8(__u32_bytes[1]); let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_168: G = __v_167 - __v_134; let __v_169: G = __v_167 - __v_136; let __v_170: G = __v_168 * __v_169; let __v_171: G = __v_167 * __v_170; if (__v_171 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_172: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_143, &__v_163) } else { aiur::execute::bytes2_xor_value(__v_143, __v_163, record) }; let __v_173: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_144, &__v_164) } else { aiur::execute::bytes2_xor_value(__v_144, __v_164, record) }; let __v_174: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_141, &__v_165) } else { aiur::execute::bytes2_xor_value(__v_141, __v_165, record) }; let __v_175: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_142, &__v_166) } else { aiur::execute::bytes2_xor_value(__v_142, __v_166, record) }; let __u32_sum: u128 = u128::from((((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8)) | (__v_147.as_canonical_u64() << 16)) | (__v_148.as_canonical_u64() << 24)) + u128::from((((__v_173.as_canonical_u64() << 0) | (__v_174.as_canonical_u64() << 8)) | (__v_175.as_canonical_u64() << 16)) | (__v_172.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_176: G = G::from_u8(__u32_bytes[0]); let __v_177: G = G::from_u8(__u32_bytes[1]); let __v_178: G = G::from_u8(__u32_bytes[2]); let __v_179: G = G::from_u8(__u32_bytes[3]); let __v_180: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_176; let __vj = __v_177; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_181: G = __v_180 * __v_180; if (__v_181 != __v_180) { return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_180.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_159, &__v_176) } else { aiur::execute::bytes2_xor_split7_value(__v_159, __v_176, record) }; let __v_182: G = __b2_out.0; let __v_183: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_160, &__v_177) } else { aiur::execute::bytes2_xor_split7_value(__v_160, __v_177, record) }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_161, &__v_178) } else { aiur::execute::bytes2_xor_split7_value(__v_161, __v_178, record) }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_162, &__v_179) } else { aiur::execute::bytes2_xor_split7_value(__v_162, __v_179, record) }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; let __v_190: G = __v_182 + __v_185; let __v_191: G = __v_184 + __v_187; let __v_192: G = __v_186 + __v_189; let __v_193: G = __v_188 + __v_183; let __u32_sum: u128 = (u128::from((((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8)) | (__v_7.as_canonical_u64() << 16)) | (__v_8.as_canonical_u64() << 24)) + u128::from((((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8)) | (__v_23.as_canonical_u64() << 16)) | (__v_24.as_canonical_u64() << 24))) + u128::from((((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8)) | (__v_75.as_canonical_u64() << 16)) | (__v_76.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_194: G = G::from_u8(__u32_bytes[0]); let __v_195: G = G::from_u8(__u32_bytes[1]); let __v_196: G = G::from_u8(__u32_bytes[2]); let __v_197: G = G::from_u8(__u32_bytes[3]); let __v_198: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_194; let __vj = __v_195; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_199: G = __v_198 - __v_134; let __v_200: G = __v_198 - __v_136; let __v_201: G = __v_199 * __v_200; let __v_202: G = __v_198 * __v_201; if (__v_202 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_203: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_53, &__v_194) } else { aiur::execute::bytes2_xor_value(__v_53, __v_194, record) }; let __v_204: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_54, &__v_195) } else { aiur::execute::bytes2_xor_value(__v_54, __v_195, record) }; let __v_205: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_55, &__v_196) } else { aiur::execute::bytes2_xor_value(__v_55, __v_196, record) }; let __v_206: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_56, &__v_197) } else { aiur::execute::bytes2_xor_value(__v_56, __v_197, record) }; let __u32_sum: u128 = u128::from((((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8)) | (__v_39.as_canonical_u64() << 16)) | (__v_40.as_canonical_u64() << 24)) + u128::from((((__v_205.as_canonical_u64() << 0) | (__v_206.as_canonical_u64() << 8)) | (__v_203.as_canonical_u64() << 16)) | (__v_204.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_207: G = G::from_u8(__u32_bytes[0]); let __v_208: G = G::from_u8(__u32_bytes[1]); let __v_209: G = G::from_u8(__u32_bytes[2]); let __v_210: G = G::from_u8(__u32_bytes[3]); let __v_211: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_207; let __vj = __v_208; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_209; let __vj = __v_210; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_212: G = __v_211 * __v_211; if (__v_212 != __v_211) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_211.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_21, &__v_207) } else { aiur::execute::bytes2_xor_split4_value(__v_21, __v_207, record) }; let __v_213: G = __b2_out.0; let __v_214: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_22, &__v_208) } else { aiur::execute::bytes2_xor_split4_value(__v_22, __v_208, record) }; let __v_215: G = __b2_out.0; let __v_216: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_23, &__v_209) } else { aiur::execute::bytes2_xor_split4_value(__v_23, __v_209, record) }; let __v_217: G = __b2_out.0; let __v_218: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_24, &__v_210) } else { aiur::execute::bytes2_xor_split4_value(__v_24, __v_210, record) }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; let __v_221: G = __v_215 + __v_218; let __v_222: G = __v_217 + __v_220; let __v_223: G = __v_219 + __v_214; let __v_224: G = __v_213 + __v_216; let __u32_sum: u128 = (u128::from((((__v_194.as_canonical_u64() << 0) | (__v_195.as_canonical_u64() << 8)) | (__v_196.as_canonical_u64() << 16)) | (__v_197.as_canonical_u64() << 24)) + u128::from((((__v_221.as_canonical_u64() << 0) | (__v_222.as_canonical_u64() << 8)) | (__v_223.as_canonical_u64() << 16)) | (__v_224.as_canonical_u64() << 24))) + u128::from((((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8)) | (__v_79.as_canonical_u64() << 16)) | (__v_80.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_225: G = G::from_u8(__u32_bytes[0]); let __v_226: G = G::from_u8(__u32_bytes[1]); let __v_227: G = G::from_u8(__u32_bytes[2]); let __v_228: G = G::from_u8(__u32_bytes[3]); let __v_229: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_225; let __vj = __v_226; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_227; let __vj = __v_228; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_230: G = __v_229 - __v_134; let __v_231: G = __v_229 - __v_136; let __v_232: G = __v_230 * __v_231; let __v_233: G = __v_229 * __v_232; if (__v_233 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_234: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_205, &__v_225) } else { aiur::execute::bytes2_xor_value(__v_205, __v_225, record) }; let __v_235: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_206, &__v_226) } else { aiur::execute::bytes2_xor_value(__v_206, __v_226, record) }; let __v_236: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_203, &__v_227) } else { aiur::execute::bytes2_xor_value(__v_203, __v_227, record) }; let __v_237: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_204, &__v_228) } else { aiur::execute::bytes2_xor_value(__v_204, __v_228, record) }; let __u32_sum: u128 = u128::from((((__v_207.as_canonical_u64() << 0) | (__v_208.as_canonical_u64() << 8)) | (__v_209.as_canonical_u64() << 16)) | (__v_210.as_canonical_u64() << 24)) + u128::from((((__v_235.as_canonical_u64() << 0) | (__v_236.as_canonical_u64() << 8)) | (__v_237.as_canonical_u64() << 16)) | (__v_234.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_238: G = G::from_u8(__u32_bytes[0]); let __v_239: G = G::from_u8(__u32_bytes[1]); let __v_240: G = G::from_u8(__u32_bytes[2]); let __v_241: G = G::from_u8(__u32_bytes[3]); let __v_242: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_238; let __vj = __v_239; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_240; let __vj = __v_241; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_243: G = __v_242 * __v_242; if (__v_243 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_221, &__v_238) } else { aiur::execute::bytes2_xor_split7_value(__v_221, __v_238, record) }; let __v_244: G = __b2_out.0; let __v_245: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_222, &__v_239) } else { aiur::execute::bytes2_xor_split7_value(__v_222, __v_239, record) }; let __v_246: G = __b2_out.0; let __v_247: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_223, &__v_240) } else { aiur::execute::bytes2_xor_split7_value(__v_223, __v_240, record) }; let __v_248: G = __b2_out.0; let __v_249: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_224, &__v_241) } else { aiur::execute::bytes2_xor_split7_value(__v_224, __v_241, record) }; let __v_250: G = __b2_out.0; let __v_251: G = __b2_out.1; let __v_252: G = __v_244 + __v_247; let __v_253: G = __v_246 + __v_249; let __v_254: G = __v_248 + __v_251; let __v_255: G = __v_250 + __v_245; let __u32_sum: u128 = (u128::from((((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8)) | (__v_11.as_canonical_u64() << 16)) | (__v_12.as_canonical_u64() << 24)) + u128::from((((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8)) | (__v_27.as_canonical_u64() << 16)) | (__v_28.as_canonical_u64() << 24))) + u128::from((((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8)) | (__v_83.as_canonical_u64() << 16)) | (__v_84.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_256: G = G::from_u8(__u32_bytes[0]); let __v_257: G = G::from_u8(__u32_bytes[1]); let __v_258: G = G::from_u8(__u32_bytes[2]); let __v_259: G = G::from_u8(__u32_bytes[3]); let __v_260: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_256; let __vj = __v_257; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_258; let __vj = __v_259; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_261: G = __v_260 - __v_134; let __v_262: G = __v_260 - __v_136; let __v_263: G = __v_261 * __v_262; let __v_264: G = __v_260 * __v_263; if (__v_264 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_265: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_57, &__v_256) } else { aiur::execute::bytes2_xor_value(__v_57, __v_256, record) }; let __v_266: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_58, &__v_257) } else { aiur::execute::bytes2_xor_value(__v_58, __v_257, record) }; let __v_267: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_59, &__v_258) } else { aiur::execute::bytes2_xor_value(__v_59, __v_258, record) }; let __v_268: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_60, &__v_259) } else { aiur::execute::bytes2_xor_value(__v_60, __v_259, record) }; let __u32_sum: u128 = u128::from((((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8)) | (__v_43.as_canonical_u64() << 16)) | (__v_44.as_canonical_u64() << 24)) + u128::from((((__v_267.as_canonical_u64() << 0) | (__v_268.as_canonical_u64() << 8)) | (__v_265.as_canonical_u64() << 16)) | (__v_266.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_269: G = G::from_u8(__u32_bytes[0]); let __v_270: G = G::from_u8(__u32_bytes[1]); let __v_271: G = G::from_u8(__u32_bytes[2]); let __v_272: G = G::from_u8(__u32_bytes[3]); let __v_273: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_269; let __vj = __v_270; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_271; let __vj = __v_272; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_274: G = __v_273 * __v_273; if (__v_274 != __v_273) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_273.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_25, &__v_269) } else { aiur::execute::bytes2_xor_split4_value(__v_25, __v_269, record) }; let __v_275: G = __b2_out.0; let __v_276: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_26, &__v_270) } else { aiur::execute::bytes2_xor_split4_value(__v_26, __v_270, record) }; let __v_277: G = __b2_out.0; let __v_278: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_27, &__v_271) } else { aiur::execute::bytes2_xor_split4_value(__v_27, __v_271, record) }; let __v_279: G = __b2_out.0; let __v_280: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_28, &__v_272) } else { aiur::execute::bytes2_xor_split4_value(__v_28, __v_272, record) }; let __v_281: G = __b2_out.0; let __v_282: G = __b2_out.1; let __v_283: G = __v_277 + __v_280; let __v_284: G = __v_279 + __v_282; let __v_285: G = __v_281 + __v_276; let __v_286: G = __v_275 + __v_278; let __u32_sum: u128 = (u128::from((((__v_256.as_canonical_u64() << 0) | (__v_257.as_canonical_u64() << 8)) | (__v_258.as_canonical_u64() << 16)) | (__v_259.as_canonical_u64() << 24)) + u128::from((((__v_283.as_canonical_u64() << 0) | (__v_284.as_canonical_u64() << 8)) | (__v_285.as_canonical_u64() << 16)) | (__v_286.as_canonical_u64() << 24))) + u128::from((((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8)) | (__v_87.as_canonical_u64() << 16)) | (__v_88.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_287: G = G::from_u8(__u32_bytes[0]); let __v_288: G = G::from_u8(__u32_bytes[1]); let __v_289: G = G::from_u8(__u32_bytes[2]); let __v_290: G = G::from_u8(__u32_bytes[3]); let __v_291: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_287; let __vj = __v_288; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_289; let __vj = __v_290; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_292: G = __v_291 - __v_134; let __v_293: G = __v_291 - __v_136; let __v_294: G = __v_292 * __v_293; let __v_295: G = __v_291 * __v_294; if (__v_295 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_295.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_296: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_267, &__v_287) } else { aiur::execute::bytes2_xor_value(__v_267, __v_287, record) }; let __v_297: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_268, &__v_288) } else { aiur::execute::bytes2_xor_value(__v_268, __v_288, record) }; let __v_298: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_265, &__v_289) } else { aiur::execute::bytes2_xor_value(__v_265, __v_289, record) }; let __v_299: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_266, &__v_290) } else { aiur::execute::bytes2_xor_value(__v_266, __v_290, record) }; let __u32_sum: u128 = u128::from((((__v_269.as_canonical_u64() << 0) | (__v_270.as_canonical_u64() << 8)) | (__v_271.as_canonical_u64() << 16)) | (__v_272.as_canonical_u64() << 24)) + u128::from((((__v_297.as_canonical_u64() << 0) | (__v_298.as_canonical_u64() << 8)) | (__v_299.as_canonical_u64() << 16)) | (__v_296.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_300: G = G::from_u8(__u32_bytes[0]); let __v_301: G = G::from_u8(__u32_bytes[1]); let __v_302: G = G::from_u8(__u32_bytes[2]); let __v_303: G = G::from_u8(__u32_bytes[3]); let __v_304: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_305: G = __v_304 * __v_304; if (__v_305 != __v_304) { return Err(ExecError::AssertEqMismatch { lhs: __v_305.as_canonical_u64(), rhs: __v_304.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_283, &__v_300) } else { aiur::execute::bytes2_xor_split7_value(__v_283, __v_300, record) }; let __v_306: G = __b2_out.0; let __v_307: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_284, &__v_301) } else { aiur::execute::bytes2_xor_split7_value(__v_284, __v_301, record) }; let __v_308: G = __b2_out.0; let __v_309: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_285, &__v_302) } else { aiur::execute::bytes2_xor_split7_value(__v_285, __v_302, record) }; let __v_310: G = __b2_out.0; let __v_311: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_286, &__v_303) } else { aiur::execute::bytes2_xor_split7_value(__v_286, __v_303, record) }; let __v_312: G = __b2_out.0; let __v_313: G = __b2_out.1; let __v_314: G = __v_306 + __v_309; let __v_315: G = __v_308 + __v_311; let __v_316: G = __v_310 + __v_313; let __v_317: G = __v_312 + __v_307; let __u32_sum: u128 = (u128::from((((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8)) | (__v_15.as_canonical_u64() << 16)) | (__v_16.as_canonical_u64() << 24)) + u128::from((((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8)) | (__v_31.as_canonical_u64() << 16)) | (__v_32.as_canonical_u64() << 24))) + u128::from((((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8)) | (__v_91.as_canonical_u64() << 16)) | (__v_92.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_318: G = G::from_u8(__u32_bytes[0]); let __v_319: G = G::from_u8(__u32_bytes[1]); let __v_320: G = G::from_u8(__u32_bytes[2]); let __v_321: G = G::from_u8(__u32_bytes[3]); let __v_322: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_318; let __vj = __v_319; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_320; let __vj = __v_321; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_323: G = __v_322 - __v_134; let __v_324: G = __v_322 - __v_136; let __v_325: G = __v_323 * __v_324; let __v_326: G = __v_322 * __v_325; if (__v_326 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_327: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_61, &__v_318) } else { aiur::execute::bytes2_xor_value(__v_61, __v_318, record) }; let __v_328: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_62, &__v_319) } else { aiur::execute::bytes2_xor_value(__v_62, __v_319, record) }; let __v_329: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_63, &__v_320) } else { aiur::execute::bytes2_xor_value(__v_63, __v_320, record) }; let __v_330: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_64, &__v_321) } else { aiur::execute::bytes2_xor_value(__v_64, __v_321, record) }; let __u32_sum: u128 = u128::from((((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8)) | (__v_47.as_canonical_u64() << 16)) | (__v_48.as_canonical_u64() << 24)) + u128::from((((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8)) | (__v_327.as_canonical_u64() << 16)) | (__v_328.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_331: G = G::from_u8(__u32_bytes[0]); let __v_332: G = G::from_u8(__u32_bytes[1]); let __v_333: G = G::from_u8(__u32_bytes[2]); let __v_334: G = G::from_u8(__u32_bytes[3]); let __v_335: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_331; let __vj = __v_332; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_336: G = __v_335 * __v_335; if (__v_336 != __v_335) { return Err(ExecError::AssertEqMismatch { lhs: __v_336.as_canonical_u64(), rhs: __v_335.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_29, &__v_331) } else { aiur::execute::bytes2_xor_split4_value(__v_29, __v_331, record) }; let __v_337: G = __b2_out.0; let __v_338: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_30, &__v_332) } else { aiur::execute::bytes2_xor_split4_value(__v_30, __v_332, record) }; let __v_339: G = __b2_out.0; let __v_340: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_31, &__v_333) } else { aiur::execute::bytes2_xor_split4_value(__v_31, __v_333, record) }; let __v_341: G = __b2_out.0; let __v_342: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_32, &__v_334) } else { aiur::execute::bytes2_xor_split4_value(__v_32, __v_334, record) }; let __v_343: G = __b2_out.0; let __v_344: G = __b2_out.1; let __v_345: G = __v_339 + __v_342; let __v_346: G = __v_341 + __v_344; let __v_347: G = __v_343 + __v_338; let __v_348: G = __v_337 + __v_340; let __u32_sum: u128 = (u128::from((((__v_318.as_canonical_u64() << 0) | (__v_319.as_canonical_u64() << 8)) | (__v_320.as_canonical_u64() << 16)) | (__v_321.as_canonical_u64() << 24)) + u128::from((((__v_345.as_canonical_u64() << 0) | (__v_346.as_canonical_u64() << 8)) | (__v_347.as_canonical_u64() << 16)) | (__v_348.as_canonical_u64() << 24))) + u128::from((((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8)) | (__v_95.as_canonical_u64() << 16)) | (__v_96.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); let __v_350: G = G::from_u8(__u32_bytes[1]); let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_354: G = __v_353 - __v_134; let __v_355: G = __v_353 - __v_136; let __v_356: G = __v_354 * __v_355; let __v_357: G = __v_353 * __v_356; if (__v_357 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_358: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_329, &__v_349) } else { aiur::execute::bytes2_xor_value(__v_329, __v_349, record) }; let __v_359: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_330, &__v_350) } else { aiur::execute::bytes2_xor_value(__v_330, __v_350, record) }; let __v_360: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_327, &__v_351) } else { aiur::execute::bytes2_xor_value(__v_327, __v_351, record) }; let __v_361: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_328, &__v_352) } else { aiur::execute::bytes2_xor_value(__v_328, __v_352, record) }; let __u32_sum: u128 = u128::from((((__v_331.as_canonical_u64() << 0) | (__v_332.as_canonical_u64() << 8)) | (__v_333.as_canonical_u64() << 16)) | (__v_334.as_canonical_u64() << 24)) + u128::from((((__v_359.as_canonical_u64() << 0) | (__v_360.as_canonical_u64() << 8)) | (__v_361.as_canonical_u64() << 16)) | (__v_358.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_362: G = G::from_u8(__u32_bytes[0]); let __v_363: G = G::from_u8(__u32_bytes[1]); let __v_364: G = G::from_u8(__u32_bytes[2]); let __v_365: G = G::from_u8(__u32_bytes[3]); let __v_366: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_362; let __vj = __v_363; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_364; let __vj = __v_365; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_367: G = __v_366 * __v_366; if (__v_367 != __v_366) { return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_366.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_345, &__v_362) } else { aiur::execute::bytes2_xor_split7_value(__v_345, __v_362, record) }; let __v_368: G = __b2_out.0; let __v_369: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_346, &__v_363) } else { aiur::execute::bytes2_xor_split7_value(__v_346, __v_363, record) }; let __v_370: G = __b2_out.0; let __v_371: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_347, &__v_364) } else { aiur::execute::bytes2_xor_split7_value(__v_347, __v_364, record) }; let __v_372: G = __b2_out.0; let __v_373: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_348, &__v_365) } else { aiur::execute::bytes2_xor_split7_value(__v_348, __v_365, record) }; let __v_374: G = __b2_out.0; let __v_375: G = __b2_out.1; let __v_376: G = __v_368 + __v_371; let __v_377: G = __v_370 + __v_373; let __v_378: G = __v_372 + __v_375; let __v_379: G = __v_374 + __v_369; let __u32_sum: u128 = (u128::from((((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8)) | (__v_165.as_canonical_u64() << 16)) | (__v_166.as_canonical_u64() << 24)) + u128::from((((__v_252.as_canonical_u64() << 0) | (__v_253.as_canonical_u64() << 8)) | (__v_254.as_canonical_u64() << 16)) | (__v_255.as_canonical_u64() << 24))) + u128::from((((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8)) | (__v_99.as_canonical_u64() << 16)) | (__v_100.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_380: G = G::from_u8(__u32_bytes[0]); let __v_381: G = G::from_u8(__u32_bytes[1]); let __v_382: G = G::from_u8(__u32_bytes[2]); let __v_383: G = G::from_u8(__u32_bytes[3]); let __v_384: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_380; let __vj = __v_381; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_385: G = __v_384 - __v_134; let __v_386: G = __v_384 - __v_136; let __v_387: G = __v_385 * __v_386; let __v_388: G = __v_384 * __v_387; if (__v_388 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_389: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_359, &__v_380) } else { aiur::execute::bytes2_xor_value(__v_359, __v_380, record) }; let __v_390: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_360, &__v_381) } else { aiur::execute::bytes2_xor_value(__v_360, __v_381, record) }; let __v_391: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_361, &__v_382) } else { aiur::execute::bytes2_xor_value(__v_361, __v_382, record) }; let __v_392: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_358, &__v_383) } else { aiur::execute::bytes2_xor_value(__v_358, __v_383, record) }; let __u32_sum: u128 = u128::from((((__v_300.as_canonical_u64() << 0) | (__v_301.as_canonical_u64() << 8)) | (__v_302.as_canonical_u64() << 16)) | (__v_303.as_canonical_u64() << 24)) + u128::from((((__v_391.as_canonical_u64() << 0) | (__v_392.as_canonical_u64() << 8)) | (__v_389.as_canonical_u64() << 16)) | (__v_390.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_393: G = G::from_u8(__u32_bytes[0]); let __v_394: G = G::from_u8(__u32_bytes[1]); let __v_395: G = G::from_u8(__u32_bytes[2]); let __v_396: G = G::from_u8(__u32_bytes[3]); let __v_397: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_393; let __vj = __v_394; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_395; let __vj = __v_396; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_398: G = __v_397 * __v_397; if (__v_398 != __v_397) { return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_397.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_252, &__v_393) } else { aiur::execute::bytes2_xor_split4_value(__v_252, __v_393, record) }; let __v_399: G = __b2_out.0; let __v_400: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_253, &__v_394) } else { aiur::execute::bytes2_xor_split4_value(__v_253, __v_394, record) }; let __v_401: G = __b2_out.0; let __v_402: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_254, &__v_395) } else { aiur::execute::bytes2_xor_split4_value(__v_254, __v_395, record) }; let __v_403: G = __b2_out.0; let __v_404: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_255, &__v_396) } else { aiur::execute::bytes2_xor_split4_value(__v_255, __v_396, record) }; let __v_405: G = __b2_out.0; let __v_406: G = __b2_out.1; let __v_407: G = __v_401 + __v_404; let __v_408: G = __v_403 + __v_406; let __v_409: G = __v_405 + __v_400; let __v_410: G = __v_399 + __v_402; let __u32_sum: u128 = (u128::from((((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8)) | (__v_382.as_canonical_u64() << 16)) | (__v_383.as_canonical_u64() << 24)) + u128::from((((__v_407.as_canonical_u64() << 0) | (__v_408.as_canonical_u64() << 8)) | (__v_409.as_canonical_u64() << 16)) | (__v_410.as_canonical_u64() << 24))) + u128::from((((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8)) | (__v_103.as_canonical_u64() << 16)) | (__v_104.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_411: G = G::from_u8(__u32_bytes[0]); let __v_412: G = G::from_u8(__u32_bytes[1]); let __v_413: G = G::from_u8(__u32_bytes[2]); let __v_414: G = G::from_u8(__u32_bytes[3]); let __v_415: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_411; let __vj = __v_412; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_413; let __vj = __v_414; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_416: G = __v_415 - __v_134; let __v_417: G = __v_415 - __v_136; let __v_418: G = __v_416 * __v_417; let __v_419: G = __v_415 * __v_418; if (__v_419 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_420: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_391, &__v_411) } else { aiur::execute::bytes2_xor_value(__v_391, __v_411, record) }; let __v_421: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_392, &__v_412) } else { aiur::execute::bytes2_xor_value(__v_392, __v_412, record) }; let __v_422: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_389, &__v_413) } else { aiur::execute::bytes2_xor_value(__v_389, __v_413, record) }; let __v_423: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_390, &__v_414) } else { aiur::execute::bytes2_xor_value(__v_390, __v_414, record) }; let __u32_sum: u128 = u128::from((((__v_393.as_canonical_u64() << 0) | (__v_394.as_canonical_u64() << 8)) | (__v_395.as_canonical_u64() << 16)) | (__v_396.as_canonical_u64() << 24)) + u128::from((((__v_421.as_canonical_u64() << 0) | (__v_422.as_canonical_u64() << 8)) | (__v_423.as_canonical_u64() << 16)) | (__v_420.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_424: G = G::from_u8(__u32_bytes[0]); let __v_425: G = G::from_u8(__u32_bytes[1]); let __v_426: G = G::from_u8(__u32_bytes[2]); let __v_427: G = G::from_u8(__u32_bytes[3]); let __v_428: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_424; let __vj = __v_425; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_426; let __vj = __v_427; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_429: G = __v_428 * __v_428; if (__v_429 != __v_428) { return Err(ExecError::AssertEqMismatch { lhs: __v_429.as_canonical_u64(), rhs: __v_428.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_407, &__v_424) } else { aiur::execute::bytes2_xor_split7_value(__v_407, __v_424, record) }; let __v_430: G = __b2_out.0; let __v_431: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_408, &__v_425) } else { aiur::execute::bytes2_xor_split7_value(__v_408, __v_425, record) }; let __v_432: G = __b2_out.0; let __v_433: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_409, &__v_426) } else { aiur::execute::bytes2_xor_split7_value(__v_409, __v_426, record) }; let __v_434: G = __b2_out.0; let __v_435: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_410, &__v_427) } else { aiur::execute::bytes2_xor_split7_value(__v_410, __v_427, record) }; let __v_436: G = __b2_out.0; let __v_437: G = __b2_out.1; let __v_438: G = __v_430 + __v_433; let __v_439: G = __v_432 + __v_435; let __v_440: G = __v_434 + __v_437; let __v_441: G = __v_436 + __v_431; let __u32_sum: u128 = (u128::from((((__v_225.as_canonical_u64() << 0) | (__v_226.as_canonical_u64() << 8)) | (__v_227.as_canonical_u64() << 16)) | (__v_228.as_canonical_u64() << 24)) + u128::from((((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8)) | (__v_316.as_canonical_u64() << 16)) | (__v_317.as_canonical_u64() << 24))) + u128::from((((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8)) | (__v_107.as_canonical_u64() << 16)) | (__v_108.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_442: G = G::from_u8(__u32_bytes[0]); let __v_443: G = G::from_u8(__u32_bytes[1]); let __v_444: G = G::from_u8(__u32_bytes[2]); let __v_445: G = G::from_u8(__u32_bytes[3]); let __v_446: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_442; let __vj = __v_443; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_444; let __vj = __v_445; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_447: G = __v_446 - __v_134; let __v_448: G = __v_446 - __v_136; let __v_449: G = __v_447 * __v_448; let __v_450: G = __v_446 * __v_449; if (__v_450 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_450.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_451: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_173, &__v_442) } else { aiur::execute::bytes2_xor_value(__v_173, __v_442, record) }; let __v_452: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_174, &__v_443) } else { aiur::execute::bytes2_xor_value(__v_174, __v_443, record) }; let __v_453: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_175, &__v_444) } else { aiur::execute::bytes2_xor_value(__v_175, __v_444, record) }; let __v_454: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_172, &__v_445) } else { aiur::execute::bytes2_xor_value(__v_172, __v_445, record) }; let __u32_sum: u128 = u128::from((((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8)) | (__v_364.as_canonical_u64() << 16)) | (__v_365.as_canonical_u64() << 24)) + u128::from((((__v_453.as_canonical_u64() << 0) | (__v_454.as_canonical_u64() << 8)) | (__v_451.as_canonical_u64() << 16)) | (__v_452.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_455: G = G::from_u8(__u32_bytes[0]); let __v_456: G = G::from_u8(__u32_bytes[1]); let __v_457: G = G::from_u8(__u32_bytes[2]); let __v_458: G = G::from_u8(__u32_bytes[3]); let __v_459: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_455; let __vj = __v_456; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_457; let __vj = __v_458; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_460: G = __v_459 * __v_459; if (__v_460 != __v_459) { return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_314, &__v_455) } else { aiur::execute::bytes2_xor_split4_value(__v_314, __v_455, record) }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_315, &__v_456) } else { aiur::execute::bytes2_xor_split4_value(__v_315, __v_456, record) }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_316, &__v_457) } else { aiur::execute::bytes2_xor_split4_value(__v_316, __v_457, record) }; let __v_465: G = __b2_out.0; let __v_466: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_317, &__v_458) } else { aiur::execute::bytes2_xor_split4_value(__v_317, __v_458, record) }; let __v_467: G = __b2_out.0; let __v_468: G = __b2_out.1; let __v_469: G = __v_463 + __v_466; let __v_470: G = __v_465 + __v_468; let __v_471: G = __v_467 + __v_462; let __v_472: G = __v_461 + __v_464; let __u32_sum: u128 = (u128::from((((__v_442.as_canonical_u64() << 0) | (__v_443.as_canonical_u64() << 8)) | (__v_444.as_canonical_u64() << 16)) | (__v_445.as_canonical_u64() << 24)) + u128::from((((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8)) | (__v_471.as_canonical_u64() << 16)) | (__v_472.as_canonical_u64() << 24))) + u128::from((((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8)) | (__v_111.as_canonical_u64() << 16)) | (__v_112.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_473: G = G::from_u8(__u32_bytes[0]); let __v_474: G = G::from_u8(__u32_bytes[1]); let __v_475: G = G::from_u8(__u32_bytes[2]); let __v_476: G = G::from_u8(__u32_bytes[3]); let __v_477: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_473; let __vj = __v_474; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_475; let __vj = __v_476; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_478: G = __v_477 - __v_134; let __v_479: G = __v_477 - __v_136; let __v_480: G = __v_478 * __v_479; let __v_481: G = __v_477 * __v_480; if (__v_481 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_482: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_453, &__v_473) } else { aiur::execute::bytes2_xor_value(__v_453, __v_473, record) }; let __v_483: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_454, &__v_474) } else { aiur::execute::bytes2_xor_value(__v_454, __v_474, record) }; let __v_484: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_451, &__v_475) } else { aiur::execute::bytes2_xor_value(__v_451, __v_475, record) }; let __v_485: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_452, &__v_476) } else { aiur::execute::bytes2_xor_value(__v_452, __v_476, record) }; let __u32_sum: u128 = u128::from((((__v_455.as_canonical_u64() << 0) | (__v_456.as_canonical_u64() << 8)) | (__v_457.as_canonical_u64() << 16)) | (__v_458.as_canonical_u64() << 24)) + u128::from((((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8)) | (__v_485.as_canonical_u64() << 16)) | (__v_482.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_486: G = G::from_u8(__u32_bytes[0]); let __v_487: G = G::from_u8(__u32_bytes[1]); let __v_488: G = G::from_u8(__u32_bytes[2]); let __v_489: G = G::from_u8(__u32_bytes[3]); let __v_490: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_488; let __vj = __v_489; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_491: G = __v_490 * __v_490; if (__v_491 != __v_490) { return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_469, &__v_486) } else { aiur::execute::bytes2_xor_split7_value(__v_469, __v_486, record) }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_470, &__v_487) } else { aiur::execute::bytes2_xor_split7_value(__v_470, __v_487, record) }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_471, &__v_488) } else { aiur::execute::bytes2_xor_split7_value(__v_471, __v_488, record) }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_472, &__v_489) } else { aiur::execute::bytes2_xor_split7_value(__v_472, __v_489, record) }; let __v_498: G = __b2_out.0; let __v_499: G = __b2_out.1; let __v_500: G = __v_492 + __v_495; let __v_501: G = __v_494 + __v_497; let __v_502: G = __v_496 + __v_499; let __v_503: G = __v_498 + __v_493; let __u32_sum: u128 = (u128::from((((__v_287.as_canonical_u64() << 0) | (__v_288.as_canonical_u64() << 8)) | (__v_289.as_canonical_u64() << 16)) | (__v_290.as_canonical_u64() << 24)) + u128::from((((__v_376.as_canonical_u64() << 0) | (__v_377.as_canonical_u64() << 8)) | (__v_378.as_canonical_u64() << 16)) | (__v_379.as_canonical_u64() << 24))) + u128::from((((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8)) | (__v_115.as_canonical_u64() << 16)) | (__v_116.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_504: G = G::from_u8(__u32_bytes[0]); let __v_505: G = G::from_u8(__u32_bytes[1]); let __v_506: G = G::from_u8(__u32_bytes[2]); let __v_507: G = G::from_u8(__u32_bytes[3]); let __v_508: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_506; let __vj = __v_507; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_509: G = __v_508 - __v_134; let __v_510: G = __v_508 - __v_136; let __v_511: G = __v_509 * __v_510; let __v_512: G = __v_508 * __v_511; if (__v_512 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_513: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_235, &__v_504) } else { aiur::execute::bytes2_xor_value(__v_235, __v_504, record) }; let __v_514: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_236, &__v_505) } else { aiur::execute::bytes2_xor_value(__v_236, __v_505, record) }; let __v_515: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_237, &__v_506) } else { aiur::execute::bytes2_xor_value(__v_237, __v_506, record) }; let __v_516: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_234, &__v_507) } else { aiur::execute::bytes2_xor_value(__v_234, __v_507, record) }; let __u32_sum: u128 = u128::from((((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8)) | (__v_178.as_canonical_u64() << 16)) | (__v_179.as_canonical_u64() << 24)) + u128::from((((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8)) | (__v_513.as_canonical_u64() << 16)) | (__v_514.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_517: G = G::from_u8(__u32_bytes[0]); let __v_518: G = G::from_u8(__u32_bytes[1]); let __v_519: G = G::from_u8(__u32_bytes[2]); let __v_520: G = G::from_u8(__u32_bytes[3]); let __v_521: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_517; let __vj = __v_518; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_522: G = __v_521 * __v_521; if (__v_522 != __v_521) { return Err(ExecError::AssertEqMismatch { lhs: __v_522.as_canonical_u64(), rhs: __v_521.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_376, &__v_517) } else { aiur::execute::bytes2_xor_split4_value(__v_376, __v_517, record) }; let __v_523: G = __b2_out.0; let __v_524: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_377, &__v_518) } else { aiur::execute::bytes2_xor_split4_value(__v_377, __v_518, record) }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_378, &__v_519) } else { aiur::execute::bytes2_xor_split4_value(__v_378, __v_519, record) }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_379, &__v_520) } else { aiur::execute::bytes2_xor_split4_value(__v_379, __v_520, record) }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; let __v_531: G = __v_525 + __v_528; let __v_532: G = __v_527 + __v_530; let __v_533: G = __v_529 + __v_524; let __v_534: G = __v_523 + __v_526; let __u32_sum: u128 = (u128::from((((__v_504.as_canonical_u64() << 0) | (__v_505.as_canonical_u64() << 8)) | (__v_506.as_canonical_u64() << 16)) | (__v_507.as_canonical_u64() << 24)) + u128::from((((__v_531.as_canonical_u64() << 0) | (__v_532.as_canonical_u64() << 8)) | (__v_533.as_canonical_u64() << 16)) | (__v_534.as_canonical_u64() << 24))) + u128::from((((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8)) | (__v_119.as_canonical_u64() << 16)) | (__v_120.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_535: G = G::from_u8(__u32_bytes[0]); let __v_536: G = G::from_u8(__u32_bytes[1]); let __v_537: G = G::from_u8(__u32_bytes[2]); let __v_538: G = G::from_u8(__u32_bytes[3]); let __v_539: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_535; let __vj = __v_536; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_540: G = __v_539 - __v_134; let __v_541: G = __v_539 - __v_136; let __v_542: G = __v_540 * __v_541; let __v_543: G = __v_539 * __v_542; if (__v_543 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_544: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_515, &__v_535) } else { aiur::execute::bytes2_xor_value(__v_515, __v_535, record) }; let __v_545: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_516, &__v_536) } else { aiur::execute::bytes2_xor_value(__v_516, __v_536, record) }; let __v_546: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_513, &__v_537) } else { aiur::execute::bytes2_xor_value(__v_513, __v_537, record) }; let __v_547: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_514, &__v_538) } else { aiur::execute::bytes2_xor_value(__v_514, __v_538, record) }; let __u32_sum: u128 = u128::from((((__v_517.as_canonical_u64() << 0) | (__v_518.as_canonical_u64() << 8)) | (__v_519.as_canonical_u64() << 16)) | (__v_520.as_canonical_u64() << 24)) + u128::from((((__v_545.as_canonical_u64() << 0) | (__v_546.as_canonical_u64() << 8)) | (__v_547.as_canonical_u64() << 16)) | (__v_544.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_548: G = G::from_u8(__u32_bytes[0]); let __v_549: G = G::from_u8(__u32_bytes[1]); let __v_550: G = G::from_u8(__u32_bytes[2]); let __v_551: G = G::from_u8(__u32_bytes[3]); let __v_552: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_548; let __vj = __v_549; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_550; let __vj = __v_551; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_553: G = __v_552 * __v_552; if (__v_553 != __v_552) { return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_552.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_531, &__v_548) } else { aiur::execute::bytes2_xor_split7_value(__v_531, __v_548, record) }; let __v_554: G = __b2_out.0; let __v_555: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_532, &__v_549) } else { aiur::execute::bytes2_xor_split7_value(__v_532, __v_549, record) }; let __v_556: G = __b2_out.0; let __v_557: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_533, &__v_550) } else { aiur::execute::bytes2_xor_split7_value(__v_533, __v_550, record) }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_534, &__v_551) } else { aiur::execute::bytes2_xor_split7_value(__v_534, __v_551, record) }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; let __v_562: G = __v_554 + __v_557; let __v_563: G = __v_556 + __v_559; let __v_564: G = __v_558 + __v_561; let __v_565: G = __v_560 + __v_555; let __u32_sum: u128 = (u128::from((((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8)) | (__v_351.as_canonical_u64() << 16)) | (__v_352.as_canonical_u64() << 24)) + u128::from((((__v_190.as_canonical_u64() << 0) | (__v_191.as_canonical_u64() << 8)) | (__v_192.as_canonical_u64() << 16)) | (__v_193.as_canonical_u64() << 24))) + u128::from((((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8)) | (__v_123.as_canonical_u64() << 16)) | (__v_124.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_566: G = G::from_u8(__u32_bytes[0]); let __v_567: G = G::from_u8(__u32_bytes[1]); let __v_568: G = G::from_u8(__u32_bytes[2]); let __v_569: G = G::from_u8(__u32_bytes[3]); let __v_570: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_566; let __vj = __v_567; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_568; let __vj = __v_569; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_571: G = __v_570 - __v_134; let __v_572: G = __v_570 - __v_136; let __v_573: G = __v_571 * __v_572; let __v_574: G = __v_570 * __v_573; if (__v_574 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_574.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_575: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_297, &__v_566) } else { aiur::execute::bytes2_xor_value(__v_297, __v_566, record) }; let __v_576: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_298, &__v_567) } else { aiur::execute::bytes2_xor_value(__v_298, __v_567, record) }; let __v_577: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_299, &__v_568) } else { aiur::execute::bytes2_xor_value(__v_299, __v_568, record) }; let __v_578: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_296, &__v_569) } else { aiur::execute::bytes2_xor_value(__v_296, __v_569, record) }; let __u32_sum: u128 = u128::from((((__v_238.as_canonical_u64() << 0) | (__v_239.as_canonical_u64() << 8)) | (__v_240.as_canonical_u64() << 16)) | (__v_241.as_canonical_u64() << 24)) + u128::from((((__v_577.as_canonical_u64() << 0) | (__v_578.as_canonical_u64() << 8)) | (__v_575.as_canonical_u64() << 16)) | (__v_576.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_579: G = G::from_u8(__u32_bytes[0]); let __v_580: G = G::from_u8(__u32_bytes[1]); let __v_581: G = G::from_u8(__u32_bytes[2]); let __v_582: G = G::from_u8(__u32_bytes[3]); let __v_583: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_579; let __vj = __v_580; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_581; let __vj = __v_582; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_584: G = __v_583 * __v_583; if (__v_584 != __v_583) { return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_583.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_190, &__v_579) } else { aiur::execute::bytes2_xor_split4_value(__v_190, __v_579, record) }; let __v_585: G = __b2_out.0; let __v_586: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_191, &__v_580) } else { aiur::execute::bytes2_xor_split4_value(__v_191, __v_580, record) }; let __v_587: G = __b2_out.0; let __v_588: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_192, &__v_581) } else { aiur::execute::bytes2_xor_split4_value(__v_192, __v_581, record) }; let __v_589: G = __b2_out.0; let __v_590: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split4(&__v_193, &__v_582) } else { aiur::execute::bytes2_xor_split4_value(__v_193, __v_582, record) }; let __v_591: G = __b2_out.0; let __v_592: G = __b2_out.1; let __v_593: G = __v_587 + __v_590; let __v_594: G = __v_589 + __v_592; let __v_595: G = __v_591 + __v_586; let __v_596: G = __v_585 + __v_588; let __u32_sum: u128 = (u128::from((((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8)) | (__v_568.as_canonical_u64() << 16)) | (__v_569.as_canonical_u64() << 24)) + u128::from((((__v_593.as_canonical_u64() << 0) | (__v_594.as_canonical_u64() << 8)) | (__v_595.as_canonical_u64() << 16)) | (__v_596.as_canonical_u64() << 24))) + u128::from((((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8)) | (__v_127.as_canonical_u64() << 16)) | (__v_128.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_597: G = G::from_u8(__u32_bytes[0]); let __v_598: G = G::from_u8(__u32_bytes[1]); let __v_599: G = G::from_u8(__u32_bytes[2]); let __v_600: G = G::from_u8(__u32_bytes[3]); let __v_601: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_597; let __vj = __v_598; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_599; let __vj = __v_600; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_602: G = __v_601 - __v_134; let __v_603: G = __v_601 - __v_136; let __v_604: G = __v_602 * __v_603; let __v_605: G = __v_601 * __v_604; if (__v_605 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_605.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __v_606: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_577, &__v_597) } else { aiur::execute::bytes2_xor_value(__v_577, __v_597, record) }; let __v_607: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_578, &__v_598) } else { aiur::execute::bytes2_xor_value(__v_578, __v_598, record) }; let __v_608: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_575, &__v_599) } else { aiur::execute::bytes2_xor_value(__v_575, __v_599, record) }; let __v_609: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_576, &__v_600) } else { aiur::execute::bytes2_xor_value(__v_576, __v_600, record) }; let __u32_sum: u128 = u128::from((((__v_579.as_canonical_u64() << 0) | (__v_580.as_canonical_u64() << 8)) | (__v_581.as_canonical_u64() << 16)) | (__v_582.as_canonical_u64() << 24)) + u128::from((((__v_607.as_canonical_u64() << 0) | (__v_608.as_canonical_u64() << 8)) | (__v_609.as_canonical_u64() << 16)) | (__v_606.as_canonical_u64() << 24)); let __u32_bytes = u32::try_from(__u32_sum & 4294967295).expect("masked").to_le_bytes(); let __v_610: G = G::from_u8(__u32_bytes[0]); let __v_611: G = G::from_u8(__u32_bytes[1]); let __v_612: G = G::from_u8(__u32_bytes[2]); let __v_613: G = G::from_u8(__u32_bytes[3]); let __v_614: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); if (!unconstrained) { let __vi = __v_610; let __vj = __v_611; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_612; let __vj = __v_613; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_615: G = __v_614 * __v_614; if (__v_615 != __v_614) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_614.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_593, &__v_610) } else { aiur::execute::bytes2_xor_split7_value(__v_593, __v_610, record) }; let __v_616: G = __b2_out.0; let __v_617: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_594, &__v_611) } else { aiur::execute::bytes2_xor_split7_value(__v_594, __v_611, record) }; let __v_618: G = __b2_out.0; let __v_619: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_595, &__v_612) } else { aiur::execute::bytes2_xor_split7_value(__v_595, __v_612, record) }; let __v_620: G = __b2_out.0; let __v_621: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::xor_split7(&__v_596, &__v_613) } else { aiur::execute::bytes2_xor_split7_value(__v_596, __v_613, record) }; let __v_622: G = __b2_out.0; let __v_623: G = __b2_out.1; let __v_624: G = __v_616 + __v_619; let __v_625: G = __v_618 + __v_621; let __v_626: G = __v_620 + __v_623; let __v_627: G = __v_622 + __v_617; let __v_628: G = __v_0 + __v_134; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_628, __v_411, __v_412, __v_413, __v_414, __v_473, __v_474, __v_475, __v_476, __v_535, __v_536, __v_537, __v_538, __v_597, __v_598, __v_599, __v_600, __v_624, __v_625, __v_626, __v_627, __v_438, __v_439, __v_440, __v_441, __v_500, __v_501, __v_502, __v_503, __v_562, __v_563, __v_564, __v_565, __v_548, __v_549, __v_550, __v_551, __v_610, __v_611, __v_612, __v_613, __v_424, __v_425, __v_426, __v_427, __v_486, __v_487, __v_488, __v_489, __v_483, __v_484, __v_485, __v_482, __v_545, __v_546, __v_547, __v_544, __v_607, __v_608, __v_609, __v_606, __v_421, __v_422, __v_423, __v_420, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_629: G = __r_arr[0]; let __v_630: G = __r_arr[1]; let __v_631: G = __r_arr[2]; let __v_632: G = __r_arr[3]; let __v_633: G = __r_arr[4]; let __v_634: G = __r_arr[5]; let __v_635: G = __r_arr[6]; let __v_636: G = __r_arr[7]; let __v_637: G = __r_arr[8]; let __v_638: G = __r_arr[9]; let __v_639: G = __r_arr[10]; let __v_640: G = __r_arr[11]; let __v_641: G = __r_arr[12]; let __v_642: G = __r_arr[13]; let __v_643: G = __r_arr[14]; let __v_644: G = __r_arr[15]; let __v_645: G = __r_arr[16]; let __v_646: G = __r_arr[17]; let __v_647: G = __r_arr[18]; let __v_648: G = __r_arr[19]; let __v_649: G = __r_arr[20]; let __v_650: G = __r_arr[21]; let __v_651: G = __r_arr[22]; let __v_652: G = __r_arr[23]; let __v_653: G = __r_arr[24]; let __v_654: G = __r_arr[25]; let __v_655: G = __r_arr[26]; let __v_656: G = __r_arr[27]; let __v_657: G = __r_arr[28]; let __v_658: G = __r_arr[29]; let __v_659: G = __r_arr[30]; let __v_660: G = __r_arr[31]; let __ret: [G; OUT_83] = [__v_629, __v_630, __v_631, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_84: usize = 1; const IN_84: usize = 1; const OUT_84: usize = 2; -fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_84] = [__v_2, __v_3]; record.function_queries[84].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_84(inp: [G; IN_84], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_84] = [__v_2, __v_3]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_85: usize = 1; const IN_85: usize = 1; const OUT_85: usize = 2; -fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_1, __v_2]; record.function_queries[85].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_85(inp: [G; IN_85], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_1, __v_2]; record.function_queries[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_86: usize = 1; const IN_86: usize = 1; const OUT_86: usize = 2; -fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __ret: [G; OUT_86] = [__v_7, __v_4]; record.function_queries[86].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_86(inp: [G; IN_86], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = __v_5 * __v_3; let __v_7: G = __v_1 + __v_6; let __ret: [G; OUT_86] = [__v_7, __v_4]; record.function_queries[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_87: usize = 1; const IN_87: usize = 1; const OUT_87: usize = 10; -fn aiur_fn_87(inp: [G; IN_87], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_87] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[87].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_87(inp: [G; IN_87], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = __v_5 * __v_3; let __v_7: G = __v_1 + __v_6; let __v_8: G = G::from_u64(0); let __ret: [G; OUT_87] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[87].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_88: usize = 1; const IN_88: usize = 1; const OUT_88: usize = 10; -fn aiur_fn_88(inp: [G; IN_88], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); let __v_10: G = (__v_9 * __v_3); let __v_11: G = G::from_u64(65536); let __v_12: G = (__v_11 * __v_5); let __v_13: G = G::from_u64(16777216); let __v_14: G = (__v_13 * __v_7); let __v_15: G = (__v_12 + __v_14); let __v_16: G = (__v_10 + __v_15); let __v_17: G = (__v_1 + __v_16); let __v_18: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[88].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_88(inp: [G; IN_88], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); let __v_10: G = __v_9 * __v_3; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_5; let __v_13: G = G::from_u64(16777216); let __v_14: G = __v_13 * __v_7; let __v_15: G = __v_12 + __v_14; let __v_16: G = __v_10 + __v_15; let __v_17: G = __v_1 + __v_16; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[88].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_89: usize = 1; const IN_89: usize = 1; const OUT_89: usize = 9; -fn aiur_fn_89(inp: [G; IN_89], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[89].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_89(inp: [G; IN_89], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_90: usize = 1; const IN_90: usize = 1; const OUT_90: usize = 2; -fn aiur_fn_90(inp: [G; IN_90], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_2); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_3); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_4); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_5); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_6); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_7); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_8); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_1 + __v_29); let __ret: [G; OUT_90] = [__v_30, __v_9]; record.function_queries[90].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_90(inp: [G; IN_90], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_2; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_3; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_4; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_5; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_6; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_7; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_8; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_1 + __v_29; let __ret: [G; OUT_90] = [__v_30, __v_9]; record.function_queries[90].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_91: usize = 1; const IN_91: usize = 1; const OUT_91: usize = 33; -fn aiur_fn_91(inp: [G; IN_91], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_91] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[91].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_91(inp: [G; IN_91], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_91] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_92: usize = 2; const IN_92: usize = 2; const OUT_92: usize = 2; -fn aiur_fn_92(inp: [G; IN_92], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_3, __v_0]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, (&__args[..]))?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { (*(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89])) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_44, __v_41]; record.function_queries[92].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_92(inp: [G; IN_92], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_3, __v_0]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(89, &__args[..])?) { [G::ZERO; OUT_89] } else { let (__hash, __hit) = record.function_queries[89].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[89].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => { aiur_fn_89::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_92] = [__v_44, __v_41]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_93: usize = 3; const IN_93: usize = 3; const OUT_93: usize = 2; -fn aiur_fn_93(inp: [G; IN_93], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 6] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_4, __v_0]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, (&__args[..]))?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { (*(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90])) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(3); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(4); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_2 + __v_5); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(6); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(7); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = (__v_1 - __v_10); let __v_13: G = (__v_2 + __v_10); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_2 + __v_8); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(9); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_5, __v_13, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_15, __v_12]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_2 + __v_7); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_93(inp: [G; IN_93], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 6] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_4, __v_0]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(90, &__args[..])?) { [G::ZERO; OUT_90] } else { let (__hash, __hit) = record.function_queries[90].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[90].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => { aiur_fn_90::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_5, __v_12, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(3); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(4); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_2 + __v_5; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_12, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(6); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(7); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_12: G = __v_1 - __v_10; let __v_13: G = __v_2 + __v_10; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 6] = [__v_16, __v_17, __v_5, __v_7, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_18, __v_15]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("vk: expression child must precede its parent".to_string()) }); } let __v_9: G = __v_1 - __v_8; let __v_10: G = __v_2 + __v_8; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(9); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_5, __v_13, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_15, __v_12]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_12, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_7, __v_7, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_13, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_12, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(2); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_7, __v_13, __v_7, __v_5, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_93] = [__v_14, __v_11]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_94: usize = 2; const IN_94: usize = 2; const OUT_94: usize = 2; -fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_3, __v_0]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_9, __v_7]; record.function_queries[94].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_94(inp: [G; IN_94], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_3, __v_0]; record.function_queries[94].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_94] = [__v_9, __v_7]; record.function_queries[94].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_95: usize = 1; const IN_95: usize = 1; const OUT_95: usize = 3; -fn aiur_fn_95(inp: [G; IN_95], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_1, __v_5, __v_6]; record.function_queries[95].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_95(inp: [G; IN_95], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_1, __v_5, __v_6]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_96: usize = 2; const IN_96: usize = 2; const OUT_96: usize = 2; -fn aiur_fn_96(inp: [G; IN_96], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_3, __v_0]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_96(inp: [G; IN_96], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_3, __v_0]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_97: usize = 3; const IN_97: usize = 3; const OUT_97: usize = 1; -fn aiur_fn_97(inp: [G; IN_97], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_97] = [__v_3]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 - __v_3); let __v_5: G = (__v_2 - __v_3); let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_3 + __v_6); let __ret: [G; OUT_97] = [__v_7]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 - __v_3); let __v_5: G = (__v_1 - __v_3); let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_97(inp: [G; IN_97], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_97] = [__v_3]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 - __v_3; let __v_5: G = __v_2 - __v_3; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_97] = [__v_7]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_0 - __v_3; let __v_5: G = __v_1 - __v_3; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_97] = [__v_6]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_98: usize = 1; const IN_98: usize = 1; const OUT_98: usize = 66; -fn aiur_fn_98(inp: [G; IN_98], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_49, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool((__v_56 == G::ZERO)); let __v_58: G = (__v_56 + __v_57); let __v_59: G = (__v_58 + __v_58); let __v_60: G = (__v_48 + __v_59); let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_61: G = G::from_u8(__gb[0]); let __v_62: G = G::from_u8(__gb[1]); let __v_63: G = G::from_u8(__gb[2]); let __v_64: G = G::from_u8(__gb[3]); let __v_65: G = G::from_u8(__gb[4]); let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_69: G = G::from_u64(256); let __v_70: G = (__v_69 * __v_62); let __v_71: G = G::from_u64(65536); let __v_72: G = (__v_71 * __v_63); let __v_73: G = G::from_u64(16777216); let __v_74: G = (__v_73 * __v_64); let __v_75: G = G::from_u64(4294967296); let __v_76: G = (__v_75 * __v_65); let __v_77: G = G::from_u64(1099511627776); let __v_78: G = (__v_77 * __v_66); let __v_79: G = G::from_u64(281474976710656); let __v_80: G = (__v_79 * __v_67); let __v_81: G = G::from_u64(72057594037927936); let __v_82: G = (__v_81 * __v_68); let __v_83: G = (__v_80 + __v_82); let __v_84: G = (__v_78 + __v_83); let __v_85: G = (__v_76 + __v_84); let __v_86: G = (__v_74 + __v_85); let __v_87: G = (__v_72 + __v_86); let __v_88: G = (__v_70 + __v_87); let __v_89: G = (__v_61 + __v_88); if (__v_89 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_90: G = G::from_u64(1020); let __v_91: G = (__v_68 - __v_90); let __v_92: G = (__v_67 + __v_91); let __v_93: G = (__v_66 + __v_92); let __v_94: G = (__v_65 + __v_93); let __v_95: G = G::from_bool((__v_94 == G::ZERO)); let __v_96: G = (__v_63 + __v_64); let __v_97: G = (__v_62 + __v_96); let __v_98: G = (__v_61 + __v_97); let __v_99: G = G::from_bool((__v_98 == G::ZERO)); let __v_100: G = G::from_u64(1); let __v_101: G = (__v_100 - __v_99); let __v_102: G = (__v_95 * __v_101); let __v_103: G = (__v_100 - __v_102); if (__v_103 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_59.as_canonical_u64().to_le_bytes(); let __v_104: G = G::from_u8(__gb[0]); let __v_105: G = G::from_u8(__gb[1]); let __v_106: G = G::from_u8(__gb[2]); let __v_107: G = G::from_u8(__gb[3]); let __v_108: G = G::from_u8(__gb[4]); let __v_109: G = G::from_u8(__gb[5]); let __v_110: G = G::from_u8(__gb[6]); let __v_111: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_104; let __vj = __v_105; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_106; let __vj = __v_107; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_112: G = (__v_69 * __v_105); let __v_113: G = (__v_71 * __v_106); let __v_114: G = (__v_73 * __v_107); let __v_115: G = (__v_75 * __v_108); let __v_116: G = (__v_77 * __v_109); let __v_117: G = (__v_79 * __v_110); let __v_118: G = (__v_81 * __v_111); let __v_119: G = (__v_117 + __v_118); let __v_120: G = (__v_116 + __v_119); let __v_121: G = (__v_115 + __v_120); let __v_122: G = (__v_114 + __v_121); let __v_123: G = (__v_113 + __v_122); let __v_124: G = (__v_112 + __v_123); let __v_125: G = (__v_104 + __v_124); if (__v_125 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_111 - __v_90); let __v_127: G = (__v_110 + __v_126); let __v_128: G = (__v_109 + __v_127); let __v_129: G = (__v_108 + __v_128); let __v_130: G = G::from_bool((__v_129 == G::ZERO)); let __v_131: G = (__v_106 + __v_107); let __v_132: G = (__v_105 + __v_131); let __v_133: G = (__v_104 + __v_132); let __v_134: G = G::from_bool((__v_133 == G::ZERO)); let __v_135: G = (__v_100 - __v_134); let __v_136: G = (__v_130 * __v_135); let __v_137: G = (__v_100 - __v_136); if (__v_137 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_137.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes(); let __v_138: G = G::from_u8(__gb[0]); let __v_139: G = G::from_u8(__gb[1]); let __v_140: G = G::from_u8(__gb[2]); let __v_141: G = G::from_u8(__gb[3]); let __v_142: G = G::from_u8(__gb[4]); let __v_143: G = G::from_u8(__gb[5]); let __v_144: G = G::from_u8(__gb[6]); let __v_145: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_138; let __vj = __v_139; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_140; let __vj = __v_141; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_142; let __vj = __v_143; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_146: G = (__v_69 * __v_139); let __v_147: G = (__v_71 * __v_140); let __v_148: G = (__v_73 * __v_141); let __v_149: G = (__v_75 * __v_142); let __v_150: G = (__v_77 * __v_143); let __v_151: G = (__v_79 * __v_144); let __v_152: G = (__v_81 * __v_145); let __v_153: G = (__v_151 + __v_152); let __v_154: G = (__v_150 + __v_153); let __v_155: G = (__v_149 + __v_154); let __v_156: G = (__v_148 + __v_155); let __v_157: G = (__v_147 + __v_156); let __v_158: G = (__v_146 + __v_157); let __v_159: G = (__v_138 + __v_158); if (__v_159 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __v_160: G = (__v_145 - __v_90); let __v_161: G = (__v_144 + __v_160); let __v_162: G = (__v_143 + __v_161); let __v_163: G = (__v_142 + __v_162); let __v_164: G = G::from_bool((__v_163 == G::ZERO)); let __v_165: G = (__v_140 + __v_141); let __v_166: G = (__v_139 + __v_165); let __v_167: G = (__v_138 + __v_166); let __v_168: G = G::from_bool((__v_167 == G::ZERO)); let __v_169: G = (__v_100 - __v_168); let __v_170: G = (__v_164 * __v_169); let __v_171: G = (__v_100 - __v_170); if (__v_171 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_98] = [__v_46, __v_43, __v_50, __v_31, __v_54, __v_41, __v_1, __v_11, __v_59, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_55]; record.function_queries[98].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_98(inp: [G; IN_98], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_49, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool(__v_56 == G::ZERO); let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_58 + __v_58; let __v_60: G = __v_48 + __v_59; let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_61: G = G::from_u8(__gb[0]); let __v_62: G = G::from_u8(__gb[1]); let __v_63: G = G::from_u8(__gb[2]); let __v_64: G = G::from_u8(__gb[3]); let __v_65: G = G::from_u8(__gb[4]); let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_69: G = G::from_u64(256); let __v_70: G = __v_69 * __v_62; let __v_71: G = G::from_u64(65536); let __v_72: G = __v_71 * __v_63; let __v_73: G = G::from_u64(16777216); let __v_74: G = __v_73 * __v_64; let __v_75: G = G::from_u64(4294967296); let __v_76: G = __v_75 * __v_65; let __v_77: G = G::from_u64(1099511627776); let __v_78: G = __v_77 * __v_66; let __v_79: G = G::from_u64(281474976710656); let __v_80: G = __v_79 * __v_67; let __v_81: G = G::from_u64(72057594037927936); let __v_82: G = __v_81 * __v_68; let __v_83: G = __v_80 + __v_82; let __v_84: G = __v_78 + __v_83; let __v_85: G = __v_76 + __v_84; let __v_86: G = __v_74 + __v_85; let __v_87: G = __v_72 + __v_86; let __v_88: G = __v_70 + __v_87; let __v_89: G = __v_61 + __v_88; if (__v_89 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_90: G = G::from_u64(1020); let __v_91: G = __v_68 - __v_90; let __v_92: G = __v_67 + __v_91; let __v_93: G = __v_66 + __v_92; let __v_94: G = __v_65 + __v_93; let __v_95: G = G::from_bool(__v_94 == G::ZERO); let __v_96: G = __v_63 + __v_64; let __v_97: G = __v_62 + __v_96; let __v_98: G = __v_61 + __v_97; let __v_99: G = G::from_bool(__v_98 == G::ZERO); let __v_100: G = G::from_u64(1); let __v_101: G = __v_100 - __v_99; let __v_102: G = __v_95 * __v_101; let __v_103: G = __v_100 - __v_102; if (__v_103 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_59.as_canonical_u64().to_le_bytes(); let __v_104: G = G::from_u8(__gb[0]); let __v_105: G = G::from_u8(__gb[1]); let __v_106: G = G::from_u8(__gb[2]); let __v_107: G = G::from_u8(__gb[3]); let __v_108: G = G::from_u8(__gb[4]); let __v_109: G = G::from_u8(__gb[5]); let __v_110: G = G::from_u8(__gb[6]); let __v_111: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_104; let __vj = __v_105; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_106; let __vj = __v_107; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_112: G = __v_69 * __v_105; let __v_113: G = __v_71 * __v_106; let __v_114: G = __v_73 * __v_107; let __v_115: G = __v_75 * __v_108; let __v_116: G = __v_77 * __v_109; let __v_117: G = __v_79 * __v_110; let __v_118: G = __v_81 * __v_111; let __v_119: G = __v_117 + __v_118; let __v_120: G = __v_116 + __v_119; let __v_121: G = __v_115 + __v_120; let __v_122: G = __v_114 + __v_121; let __v_123: G = __v_113 + __v_122; let __v_124: G = __v_112 + __v_123; let __v_125: G = __v_104 + __v_124; if (__v_125 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None }); } let __v_126: G = __v_111 - __v_90; let __v_127: G = __v_110 + __v_126; let __v_128: G = __v_109 + __v_127; let __v_129: G = __v_108 + __v_128; let __v_130: G = G::from_bool(__v_129 == G::ZERO); let __v_131: G = __v_106 + __v_107; let __v_132: G = __v_105 + __v_131; let __v_133: G = __v_104 + __v_132; let __v_134: G = G::from_bool(__v_133 == G::ZERO); let __v_135: G = __v_100 - __v_134; let __v_136: G = __v_130 * __v_135; let __v_137: G = __v_100 - __v_136; if (__v_137 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_137.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes(); let __v_138: G = G::from_u8(__gb[0]); let __v_139: G = G::from_u8(__gb[1]); let __v_140: G = G::from_u8(__gb[2]); let __v_141: G = G::from_u8(__gb[3]); let __v_142: G = G::from_u8(__gb[4]); let __v_143: G = G::from_u8(__gb[5]); let __v_144: G = G::from_u8(__gb[6]); let __v_145: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_138; let __vj = __v_139; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_140; let __vj = __v_141; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_142; let __vj = __v_143; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_146: G = __v_69 * __v_139; let __v_147: G = __v_71 * __v_140; let __v_148: G = __v_73 * __v_141; let __v_149: G = __v_75 * __v_142; let __v_150: G = __v_77 * __v_143; let __v_151: G = __v_79 * __v_144; let __v_152: G = __v_81 * __v_145; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_150 + __v_153; let __v_155: G = __v_149 + __v_154; let __v_156: G = __v_148 + __v_155; let __v_157: G = __v_147 + __v_156; let __v_158: G = __v_146 + __v_157; let __v_159: G = __v_138 + __v_158; if (__v_159 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __v_160: G = __v_145 - __v_90; let __v_161: G = __v_144 + __v_160; let __v_162: G = __v_143 + __v_161; let __v_163: G = __v_142 + __v_162; let __v_164: G = G::from_bool(__v_163 == G::ZERO); let __v_165: G = __v_140 + __v_141; let __v_166: G = __v_139 + __v_165; let __v_167: G = __v_138 + __v_166; let __v_168: G = G::from_bool(__v_167 == G::ZERO); let __v_169: G = __v_100 - __v_168; let __v_170: G = __v_164 * __v_169; let __v_171: G = __v_100 - __v_170; if (__v_171 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_98] = [__v_46, __v_43, __v_50, __v_31, __v_54, __v_41, __v_1, __v_11, __v_59, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_55]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_99: usize = 57; const IN_99: usize = 57; const OUT_99: usize = 1; -fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 10] = [__v_57, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 10] = [__v_57, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 10] = [__v_57, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_59]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 10] = [__v_57, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_60]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 10] = [__v_57, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_61]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 10] = [__v_57, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_62]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_63]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_64]; record.function_queries[99].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_99(inp: [G; IN_99], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; let __v_49: G = inp[49]; let __v_50: G = inp[50]; let __v_51: G = inp[51]; let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; let __v_55: G = inp[55]; let __v_56: G = inp[56]; let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 10] = [__v_57, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_59: G = { let __values: [G; 10] = [__v_57, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_60: G = { let __values: [G; 10] = [__v_57, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_59]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_61: G = { let __values: [G; 10] = [__v_57, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_60]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_62: G = { let __values: [G; 10] = [__v_57, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_61]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_63: G = { let __values: [G; 10] = [__v_57, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_62]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_64: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_63]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_99] = [__v_64]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_100: usize = 2; const IN_100: usize = 2; const OUT_100: usize = 3; -fn aiur_fn_100(inp: [G; IN_100], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_4: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_3, __v_4, __v_0]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, (&__args[..]))?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { (*(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88])) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = __r_arr[3]; let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = __r_arr[6]; let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, (&__args[..]))?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { (*(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85])) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, (&__args[..]))?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { (*(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93])) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_50, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, (&__args[..]))?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { (*(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94])) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, (&__args[..]))?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { (*(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96])) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, (&__args[..]))?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { (*(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97])) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool((__v_57 == G::ZERO)); let __v_59: G = (__v_57 + __v_58); let __v_60: G = (__v_59 + __v_59); let __v_61: G = (__v_49 + __v_60); let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes(); let __v_62: G = G::from_u8(__gb[0]); let __v_63: G = G::from_u8(__gb[1]); let __v_64: G = G::from_u8(__gb[2]); let __v_65: G = G::from_u8(__gb[3]); let __v_66: G = G::from_u8(__gb[4]); let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_70: G = G::from_u64(256); let __v_71: G = (__v_70 * __v_63); let __v_72: G = G::from_u64(65536); let __v_73: G = (__v_72 * __v_64); let __v_74: G = G::from_u64(16777216); let __v_75: G = (__v_74 * __v_65); let __v_76: G = G::from_u64(4294967296); let __v_77: G = (__v_76 * __v_66); let __v_78: G = G::from_u64(1099511627776); let __v_79: G = (__v_78 * __v_67); let __v_80: G = G::from_u64(281474976710656); let __v_81: G = (__v_80 * __v_68); let __v_82: G = G::from_u64(72057594037927936); let __v_83: G = (__v_82 * __v_69); let __v_84: G = (__v_81 + __v_83); let __v_85: G = (__v_79 + __v_84); let __v_86: G = (__v_77 + __v_85); let __v_87: G = (__v_75 + __v_86); let __v_88: G = (__v_73 + __v_87); let __v_89: G = (__v_71 + __v_88); let __v_90: G = (__v_62 + __v_89); if (__v_90 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None }); } let __v_91: G = G::from_u64(1020); let __v_92: G = (__v_69 - __v_91); let __v_93: G = (__v_68 + __v_92); let __v_94: G = (__v_67 + __v_93); let __v_95: G = (__v_66 + __v_94); let __v_96: G = G::from_bool((__v_95 == G::ZERO)); let __v_97: G = (__v_64 + __v_65); let __v_98: G = (__v_63 + __v_97); let __v_99: G = (__v_62 + __v_98); let __v_100: G = G::from_bool((__v_99 == G::ZERO)); let __v_101: G = G::from_u64(1); let __v_102: G = (__v_101 - __v_100); let __v_103: G = (__v_96 * __v_102); let __v_104: G = (__v_101 - __v_103); if (__v_104 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_105: G = G::from_u8(__gb[0]); let __v_106: G = G::from_u8(__gb[1]); let __v_107: G = G::from_u8(__gb[2]); let __v_108: G = G::from_u8(__gb[3]); let __v_109: G = G::from_u8(__gb[4]); let __v_110: G = G::from_u8(__gb[5]); let __v_111: G = G::from_u8(__gb[6]); let __v_112: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_105; let __vj = __v_106; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_113: G = (__v_70 * __v_106); let __v_114: G = (__v_72 * __v_107); let __v_115: G = (__v_74 * __v_108); let __v_116: G = (__v_76 * __v_109); let __v_117: G = (__v_78 * __v_110); let __v_118: G = (__v_80 * __v_111); let __v_119: G = (__v_82 * __v_112); let __v_120: G = (__v_118 + __v_119); let __v_121: G = (__v_117 + __v_120); let __v_122: G = (__v_116 + __v_121); let __v_123: G = (__v_115 + __v_122); let __v_124: G = (__v_114 + __v_123); let __v_125: G = (__v_113 + __v_124); let __v_126: G = (__v_105 + __v_125); if (__v_126 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_127: G = (__v_112 - __v_91); let __v_128: G = (__v_111 + __v_127); let __v_129: G = (__v_110 + __v_128); let __v_130: G = (__v_109 + __v_129); let __v_131: G = G::from_bool((__v_130 == G::ZERO)); let __v_132: G = (__v_107 + __v_108); let __v_133: G = (__v_106 + __v_132); let __v_134: G = (__v_105 + __v_133); let __v_135: G = G::from_bool((__v_134 == G::ZERO)); let __v_136: G = (__v_101 - __v_135); let __v_137: G = (__v_131 * __v_136); let __v_138: G = (__v_101 - __v_137); if (__v_138 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes(); let __v_139: G = G::from_u8(__gb[0]); let __v_140: G = G::from_u8(__gb[1]); let __v_141: G = G::from_u8(__gb[2]); let __v_142: G = G::from_u8(__gb[3]); let __v_143: G = G::from_u8(__gb[4]); let __v_144: G = G::from_u8(__gb[5]); let __v_145: G = G::from_u8(__gb[6]); let __v_146: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_139; let __vj = __v_140; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_141; let __vj = __v_142; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_143; let __vj = __v_144; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_147: G = (__v_70 * __v_140); let __v_148: G = (__v_72 * __v_141); let __v_149: G = (__v_74 * __v_142); let __v_150: G = (__v_76 * __v_143); let __v_151: G = (__v_78 * __v_144); let __v_152: G = (__v_80 * __v_145); let __v_153: G = (__v_82 * __v_146); let __v_154: G = (__v_152 + __v_153); let __v_155: G = (__v_151 + __v_154); let __v_156: G = (__v_150 + __v_155); let __v_157: G = (__v_149 + __v_156); let __v_158: G = (__v_148 + __v_157); let __v_159: G = (__v_147 + __v_158); let __v_160: G = (__v_139 + __v_159); if (__v_160 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_161: G = (__v_146 - __v_91); let __v_162: G = (__v_145 + __v_161); let __v_163: G = (__v_144 + __v_162); let __v_164: G = (__v_143 + __v_163); let __v_165: G = G::from_bool((__v_164 == G::ZERO)); let __v_166: G = (__v_141 + __v_142); let __v_167: G = (__v_140 + __v_166); let __v_168: G = (__v_139 + __v_167); let __v_169: G = G::from_bool((__v_168 == G::ZERO)); let __v_170: G = (__v_101 - __v_169); let __v_171: G = (__v_165 * __v_170); let __v_172: G = (__v_101 - __v_171); if (__v_172 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __v_173: G = (__v_1 - __v_101); let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __v_176: G = __r_arr[2]; let __v_177: G = { let __values: [G; 11] = [__v_46, __v_47, __v_44, __v_51, __v_32, __v_55, __v_42, __v_2, __v_12, __v_60, __v_174]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_178: G = { let __values: [G; 10] = [__v_46, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_175]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_179: G = { let __values: [G; 10] = [__v_46, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_178]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_180: G = { let __values: [G; 10] = [__v_46, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_179]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_181: G = { let __values: [G; 10] = [__v_46, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_180]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_182: G = { let __values: [G; 10] = [__v_46, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_181]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_183: G = { let __values: [G; 10] = [__v_46, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_182]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_184: G = { let __values: [G; 10] = [__v_46, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_183]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_177, __v_184, __v_176]; record.function_queries[100].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_100(inp: [G; IN_100], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 11] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_4: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_3, __v_4, __v_0]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(88, &__args[..])?) { [G::ZERO; OUT_88] } else { let (__hash, __hit) = record.function_queries[88].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[88].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => { aiur_fn_88::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = __r_arr[3]; let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = __r_arr[6]; let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(85, &__args[..])?) { [G::ZERO; OUT_85] } else { let (__hash, __hit) = record.function_queries[85].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[85].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => { aiur_fn_85::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(93, &__args[..])?) { [G::ZERO; OUT_93] } else { let (__hash, __hit) = record.function_queries[93].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[93].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => { aiur_fn_93::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_50, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(94, &__args[..])?) { [G::ZERO; OUT_94] } else { let (__hash, __hit) = record.function_queries[94].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[94].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => { aiur_fn_94::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(96, &__args[..])?) { [G::ZERO; OUT_96] } else { let (__hash, __hit) = record.function_queries[96].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[96].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => { aiur_fn_96::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(97, &__args[..])?) { [G::ZERO; OUT_97] } else { let (__hash, __hit) = record.function_queries[97].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[97].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => { aiur_fn_97::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool(__v_57 == G::ZERO); let __v_59: G = __v_57 + __v_58; let __v_60: G = __v_59 + __v_59; let __v_61: G = __v_49 + __v_60; let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes(); let __v_62: G = G::from_u8(__gb[0]); let __v_63: G = G::from_u8(__gb[1]); let __v_64: G = G::from_u8(__gb[2]); let __v_65: G = G::from_u8(__gb[3]); let __v_66: G = G::from_u8(__gb[4]); let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_70: G = G::from_u64(256); let __v_71: G = __v_70 * __v_63; let __v_72: G = G::from_u64(65536); let __v_73: G = __v_72 * __v_64; let __v_74: G = G::from_u64(16777216); let __v_75: G = __v_74 * __v_65; let __v_76: G = G::from_u64(4294967296); let __v_77: G = __v_76 * __v_66; let __v_78: G = G::from_u64(1099511627776); let __v_79: G = __v_78 * __v_67; let __v_80: G = G::from_u64(281474976710656); let __v_81: G = __v_80 * __v_68; let __v_82: G = G::from_u64(72057594037927936); let __v_83: G = __v_82 * __v_69; let __v_84: G = __v_81 + __v_83; let __v_85: G = __v_79 + __v_84; let __v_86: G = __v_77 + __v_85; let __v_87: G = __v_75 + __v_86; let __v_88: G = __v_73 + __v_87; let __v_89: G = __v_71 + __v_88; let __v_90: G = __v_62 + __v_89; if (__v_90 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None }); } let __v_91: G = G::from_u64(1020); let __v_92: G = __v_69 - __v_91; let __v_93: G = __v_68 + __v_92; let __v_94: G = __v_67 + __v_93; let __v_95: G = __v_66 + __v_94; let __v_96: G = G::from_bool(__v_95 == G::ZERO); let __v_97: G = __v_64 + __v_65; let __v_98: G = __v_63 + __v_97; let __v_99: G = __v_62 + __v_98; let __v_100: G = G::from_bool(__v_99 == G::ZERO); let __v_101: G = G::from_u64(1); let __v_102: G = __v_101 - __v_100; let __v_103: G = __v_96 * __v_102; let __v_104: G = __v_101 - __v_103; if (__v_104 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes(); let __v_105: G = G::from_u8(__gb[0]); let __v_106: G = G::from_u8(__gb[1]); let __v_107: G = G::from_u8(__gb[2]); let __v_108: G = G::from_u8(__gb[3]); let __v_109: G = G::from_u8(__gb[4]); let __v_110: G = G::from_u8(__gb[5]); let __v_111: G = G::from_u8(__gb[6]); let __v_112: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_105; let __vj = __v_106; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_113: G = __v_70 * __v_106; let __v_114: G = __v_72 * __v_107; let __v_115: G = __v_74 * __v_108; let __v_116: G = __v_76 * __v_109; let __v_117: G = __v_78 * __v_110; let __v_118: G = __v_80 * __v_111; let __v_119: G = __v_82 * __v_112; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_117 + __v_120; let __v_122: G = __v_116 + __v_121; let __v_123: G = __v_115 + __v_122; let __v_124: G = __v_114 + __v_123; let __v_125: G = __v_113 + __v_124; let __v_126: G = __v_105 + __v_125; if (__v_126 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); } let __v_127: G = __v_112 - __v_91; let __v_128: G = __v_111 + __v_127; let __v_129: G = __v_110 + __v_128; let __v_130: G = __v_109 + __v_129; let __v_131: G = G::from_bool(__v_130 == G::ZERO); let __v_132: G = __v_107 + __v_108; let __v_133: G = __v_106 + __v_132; let __v_134: G = __v_105 + __v_133; let __v_135: G = G::from_bool(__v_134 == G::ZERO); let __v_136: G = __v_101 - __v_135; let __v_137: G = __v_131 * __v_136; let __v_138: G = __v_101 - __v_137; if (__v_138 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes(); let __v_139: G = G::from_u8(__gb[0]); let __v_140: G = G::from_u8(__gb[1]); let __v_141: G = G::from_u8(__gb[2]); let __v_142: G = G::from_u8(__gb[3]); let __v_143: G = G::from_u8(__gb[4]); let __v_144: G = G::from_u8(__gb[5]); let __v_145: G = G::from_u8(__gb[6]); let __v_146: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_139; let __vj = __v_140; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_141; let __vj = __v_142; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_143; let __vj = __v_144; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_147: G = __v_70 * __v_140; let __v_148: G = __v_72 * __v_141; let __v_149: G = __v_74 * __v_142; let __v_150: G = __v_76 * __v_143; let __v_151: G = __v_78 * __v_144; let __v_152: G = __v_80 * __v_145; let __v_153: G = __v_82 * __v_146; let __v_154: G = __v_152 + __v_153; let __v_155: G = __v_151 + __v_154; let __v_156: G = __v_150 + __v_155; let __v_157: G = __v_149 + __v_156; let __v_158: G = __v_148 + __v_157; let __v_159: G = __v_147 + __v_158; let __v_160: G = __v_139 + __v_159; if (__v_160 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_161: G = __v_146 - __v_91; let __v_162: G = __v_145 + __v_161; let __v_163: G = __v_144 + __v_162; let __v_164: G = __v_143 + __v_163; let __v_165: G = G::from_bool(__v_164 == G::ZERO); let __v_166: G = __v_141 + __v_142; let __v_167: G = __v_140 + __v_166; let __v_168: G = __v_139 + __v_167; let __v_169: G = G::from_bool(__v_168 == G::ZERO); let __v_170: G = __v_101 - __v_169; let __v_171: G = __v_165 * __v_170; let __v_172: G = __v_101 - __v_171; if (__v_172 != __v_101) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_101.as_canonical_u64(), msg: None }); } let __v_173: G = __v_1 - __v_101; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __v_176: G = __r_arr[2]; let __v_177: G = { let __values: [G; 11] = [__v_46, __v_47, __v_44, __v_51, __v_32, __v_55, __v_42, __v_2, __v_12, __v_60, __v_174]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_178: G = { let __values: [G; 10] = [__v_46, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_175]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_179: G = { let __values: [G; 10] = [__v_46, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_178]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_180: G = { let __values: [G; 10] = [__v_46, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_179]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_181: G = { let __values: [G; 10] = [__v_46, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_180]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_182: G = { let __values: [G; 10] = [__v_46, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_181]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_183: G = { let __values: [G; 10] = [__v_46, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_182]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_184: G = { let __values: [G; 10] = [__v_46, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_183]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_100] = [__v_177, __v_184, __v_176]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_101: usize = 1; const IN_101: usize = 1; const OUT_101: usize = 3; -fn aiur_fn_101(inp: [G; IN_101], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, (&__args[..]))?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { (*(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84])) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_101] = [__v_3, __v_3, __v_2]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, (&__args[..]))?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { (*(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92])) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_101] = [__v_7, __v_5, __v_6]; record.function_queries[101].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_101(inp: [G; IN_101], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(84, &__args[..])?) { [G::ZERO; OUT_84] } else { let (__hash, __hit) = record.function_queries[84].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[84].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => { aiur_fn_84::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_101] = [__v_3, __v_3, __v_2]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(92, &__args[..])?) { [G::ZERO; OUT_92] } else { let (__hash, __hit) = record.function_queries[92].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[92].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => { aiur_fn_92::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_101] = [__v_7, __v_5, __v_6]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_102: usize = 2; const IN_102: usize = 2; const OUT_102: usize = 2; -fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_3, __v_0]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, (&__args[..]))?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { (*(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86])) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, (&__args[..]))?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { (*(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102])) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { 65535u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_9, __v_7]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_10, __v_7]; record.function_queries[102].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_102(inp: [G; IN_102], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_3, __v_0]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(86, &__args[..])?) { [G::ZERO; OUT_86] } else { let (__hash, __hit) = record.function_queries[86].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[86].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => { aiur_fn_86::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, &__args[..])?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { 65535u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_9, __v_7]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_102] = [__v_10, __v_7]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_103: usize = 1; const IN_103: usize = 1; const OUT_103: usize = 9; -fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[103].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_103(inp: [G; IN_103], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_103] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_104: usize = 1; const IN_104: usize = 1; const OUT_104: usize = 13; -fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = __r_arr[4]; let __v_86: G = __r_arr[5]; let __v_87: G = __r_arr[6]; let __v_88: G = __r_arr[7]; let __v_89: G = __r_arr[8]; let __v_90: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, (&__args[..]))?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { (*(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101])) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_96, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, (&__args[..]))?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { (*(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102])) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = { let __values: [G; 10] = [__v_71, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_92]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_80, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_100, __v_91, __v_94, __v_95, __v_97, __v_98]; record.function_queries[104].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_104(inp: [G; IN_104], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; let __v_34: G = __r_arr[3]; let __v_35: G = __r_arr[4]; let __v_36: G = __r_arr[5]; let __v_37: G = __r_arr[6]; let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = __r_arr[3]; let __v_45: G = __r_arr[4]; let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; let __v_54: G = __r_arr[3]; let __v_55: G = __r_arr[4]; let __v_56: G = __r_arr[5]; let __v_57: G = __r_arr[6]; let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 10] = [__v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72, __v_72]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_74: G = { let __values: [G; 10] = [__v_71, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_73]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_75: G = { let __values: [G; 10] = [__v_71, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_74]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_76: G = { let __values: [G; 10] = [__v_71, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_75]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_77: G = { let __values: [G; 10] = [__v_71, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_78: G = { let __values: [G; 10] = [__v_71, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_77]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_79: G = { let __values: [G; 10] = [__v_71, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_78]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_80: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_79]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = __r_arr[4]; let __v_86: G = __r_arr[5]; let __v_87: G = __r_arr[6]; let __v_88: G = __r_arr[7]; let __v_89: G = __r_arr[8]; let __v_90: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, &__args[..])?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_96, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, &__args[..])?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = { let __values: [G; 10] = [__v_71, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_92]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_80, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, &__args[..])?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_100, __v_91, __v_94, __v_95, __v_97, __v_98]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_105: usize = 5; const IN_105: usize = 5; const OUT_105: usize = 1; -fn aiur_fn_105(inp: [G; IN_105], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_9]; record.function_queries[105].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_105(inp: [G; IN_105], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_105] = [__v_9]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_106: usize = 33; const IN_106: usize = 33; const OUT_106: usize = 1; -fn aiur_fn_106(inp: [G; IN_106], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_106] = [__v_40]; record.function_queries[106].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_106(inp: [G; IN_106], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_106] = [__v_40]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_107: usize = 32; const IN_107: usize = 32; const OUT_107: usize = 32; -fn aiur_fn_107(inp: [G; IN_107], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __ret: [G; OUT_107] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[107].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_107(inp: [G; IN_107], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __ret: [G; OUT_107] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[107].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_108: usize = 2; const IN_108: usize = 2; const OUT_108: usize = 1; -fn aiur_fn_108(inp: [G; IN_108], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(133); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(187); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(243); let __v_11: G = G::from_u64(110); let __v_12: G = G::from_u64(60); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(245); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(165); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(14); let __v_20: G = G::from_u64(81); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(171); let __v_26: G = G::from_u64(217); let __v_27: G = G::from_u64(131); let __v_28: G = G::from_u64(31); let __v_29: G = G::from_u64(25); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(224); let __v_32: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; let __v_36: G = __loaded[3]; let __v_37: G = __loaded[4]; let __v_38: G = __loaded[5]; let __v_39: G = __loaded[6]; let __v_40: G = __loaded[7]; let __v_41: G = __loaded[8]; let __v_42: G = __loaded[9]; let __v_43: G = __loaded[10]; let __v_44: G = __loaded[11]; let __v_45: G = __loaded[12]; let __v_46: G = __loaded[13]; let __v_47: G = __loaded[14]; let __v_48: G = __loaded[15]; let __v_49: G = __loaded[16]; let __v_50: G = __loaded[17]; let __v_51: G = __loaded[18]; let __v_52: G = __loaded[19]; let __v_53: G = __loaded[20]; let __v_54: G = __loaded[21]; let __v_55: G = __loaded[22]; let __v_56: G = __loaded[23]; let __v_57: G = __loaded[24]; let __v_58: G = __loaded[25]; let __v_59: G = __loaded[26]; let __v_60: G = __loaded[27]; let __v_61: G = __loaded[28]; let __v_62: G = __loaded[29]; let __v_63: G = __loaded[30]; let __v_64: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_65: G = __loaded[0]; let __v_66: G = __loaded[1]; let __v_67: G = __loaded[2]; let __v_68: G = __loaded[3]; let __v_69: G = __loaded[4]; let __v_70: G = __loaded[5]; let __v_71: G = __loaded[6]; let __v_72: G = __loaded[7]; let __v_73: G = __loaded[8]; let __v_74: G = __loaded[9]; let __v_75: G = __loaded[10]; let __v_76: G = __loaded[11]; let __v_77: G = __loaded[12]; let __v_78: G = __loaded[13]; let __v_79: G = __loaded[14]; let __v_80: G = __loaded[15]; let __v_81: G = __loaded[16]; let __v_82: G = __loaded[17]; let __v_83: G = __loaded[18]; let __v_84: G = __loaded[19]; let __v_85: G = __loaded[20]; let __v_86: G = __loaded[21]; let __v_87: G = __loaded[22]; let __v_88: G = __loaded[23]; let __v_89: G = __loaded[24]; let __v_90: G = __loaded[25]; let __v_91: G = __loaded[26]; let __v_92: G = __loaded[27]; let __v_93: G = __loaded[28]; let __v_94: G = __loaded[29]; let __v_95: G = __loaded[30]; let __v_96: G = __loaded[31]; let __v_97: G = G::from_u64(0); let __v_98: G = G::from_u64(64); let __v_99: G = G::from_u64(11); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_97, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_98, __v_97, __v_97, __v_97, __v_99, __v_97, __v_97, __v_97, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; let __v_103: G = __r_arr[3]; let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = __r_arr[6]; let __v_107: G = __r_arr[7]; let __v_108: G = __r_arr[8]; let __v_109: G = __r_arr[9]; let __v_110: G = __r_arr[10]; let __v_111: G = __r_arr[11]; let __v_112: G = __r_arr[12]; let __v_113: G = __r_arr[13]; let __v_114: G = __r_arr[14]; let __v_115: G = __r_arr[15]; let __v_116: G = __r_arr[16]; let __v_117: G = __r_arr[17]; let __v_118: G = __r_arr[18]; let __v_119: G = __r_arr[19]; let __v_120: G = __r_arr[20]; let __v_121: G = __r_arr[21]; let __v_122: G = __r_arr[22]; let __v_123: G = __r_arr[23]; let __v_124: G = __r_arr[24]; let __v_125: G = __r_arr[25]; let __v_126: G = __r_arr[26]; let __v_127: G = __r_arr[27]; let __v_128: G = __r_arr[28]; let __v_129: G = __r_arr[29]; let __v_130: G = __r_arr[30]; let __v_131: G = __r_arr[31]; let __v_132: G = { let __values: [G; 32] = [__v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_108] = [__v_132]; record.function_queries[108].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_108(inp: [G; IN_108], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); let __v_5: G = G::from_u64(106); let __v_6: G = G::from_u64(133); let __v_7: G = G::from_u64(174); let __v_8: G = G::from_u64(187); let __v_9: G = G::from_u64(114); let __v_10: G = G::from_u64(243); let __v_11: G = G::from_u64(110); let __v_12: G = G::from_u64(60); let __v_13: G = G::from_u64(58); let __v_14: G = G::from_u64(245); let __v_15: G = G::from_u64(79); let __v_16: G = G::from_u64(165); let __v_17: G = G::from_u64(127); let __v_18: G = G::from_u64(82); let __v_19: G = G::from_u64(14); let __v_20: G = G::from_u64(81); let __v_21: G = G::from_u64(140); let __v_22: G = G::from_u64(104); let __v_23: G = G::from_u64(5); let __v_24: G = G::from_u64(155); let __v_25: G = G::from_u64(171); let __v_26: G = G::from_u64(217); let __v_27: G = G::from_u64(131); let __v_28: G = G::from_u64(31); let __v_29: G = G::from_u64(25); let __v_30: G = G::from_u64(205); let __v_31: G = G::from_u64(224); let __v_32: G = G::from_u64(91); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; let __v_36: G = __loaded[3]; let __v_37: G = __loaded[4]; let __v_38: G = __loaded[5]; let __v_39: G = __loaded[6]; let __v_40: G = __loaded[7]; let __v_41: G = __loaded[8]; let __v_42: G = __loaded[9]; let __v_43: G = __loaded[10]; let __v_44: G = __loaded[11]; let __v_45: G = __loaded[12]; let __v_46: G = __loaded[13]; let __v_47: G = __loaded[14]; let __v_48: G = __loaded[15]; let __v_49: G = __loaded[16]; let __v_50: G = __loaded[17]; let __v_51: G = __loaded[18]; let __v_52: G = __loaded[19]; let __v_53: G = __loaded[20]; let __v_54: G = __loaded[21]; let __v_55: G = __loaded[22]; let __v_56: G = __loaded[23]; let __v_57: G = __loaded[24]; let __v_58: G = __loaded[25]; let __v_59: G = __loaded[26]; let __v_60: G = __loaded[27]; let __v_61: G = __loaded[28]; let __v_62: G = __loaded[29]; let __v_63: G = __loaded[30]; let __v_64: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_65: G = __loaded[0]; let __v_66: G = __loaded[1]; let __v_67: G = __loaded[2]; let __v_68: G = __loaded[3]; let __v_69: G = __loaded[4]; let __v_70: G = __loaded[5]; let __v_71: G = __loaded[6]; let __v_72: G = __loaded[7]; let __v_73: G = __loaded[8]; let __v_74: G = __loaded[9]; let __v_75: G = __loaded[10]; let __v_76: G = __loaded[11]; let __v_77: G = __loaded[12]; let __v_78: G = __loaded[13]; let __v_79: G = __loaded[14]; let __v_80: G = __loaded[15]; let __v_81: G = __loaded[16]; let __v_82: G = __loaded[17]; let __v_83: G = __loaded[18]; let __v_84: G = __loaded[19]; let __v_85: G = __loaded[20]; let __v_86: G = __loaded[21]; let __v_87: G = __loaded[22]; let __v_88: G = __loaded[23]; let __v_89: G = __loaded[24]; let __v_90: G = __loaded[25]; let __v_91: G = __loaded[26]; let __v_92: G = __loaded[27]; let __v_93: G = __loaded[28]; let __v_94: G = __loaded[29]; let __v_95: G = __loaded[30]; let __v_96: G = __loaded[31]; let __v_97: G = G::from_u64(0); let __v_98: G = G::from_u64(64); let __v_99: G = G::from_u64(11); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_97, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_98, __v_97, __v_97, __v_97, __v_99, __v_97, __v_97, __v_97, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; let __v_103: G = __r_arr[3]; let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = __r_arr[6]; let __v_107: G = __r_arr[7]; let __v_108: G = __r_arr[8]; let __v_109: G = __r_arr[9]; let __v_110: G = __r_arr[10]; let __v_111: G = __r_arr[11]; let __v_112: G = __r_arr[12]; let __v_113: G = __r_arr[13]; let __v_114: G = __r_arr[14]; let __v_115: G = __r_arr[15]; let __v_116: G = __r_arr[16]; let __v_117: G = __r_arr[17]; let __v_118: G = __r_arr[18]; let __v_119: G = __r_arr[19]; let __v_120: G = __r_arr[20]; let __v_121: G = __r_arr[21]; let __v_122: G = __r_arr[22]; let __v_123: G = __r_arr[23]; let __v_124: G = __r_arr[24]; let __v_125: G = __r_arr[25]; let __v_126: G = __r_arr[26]; let __v_127: G = __r_arr[27]; let __v_128: G = __r_arr[28]; let __v_129: G = __r_arr[29]; let __v_130: G = __r_arr[30]; let __v_131: G = __r_arr[31]; let __v_132: G = { let __values: [G; 32] = [__v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_108] = [__v_132]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_109: usize = 3; const IN_109: usize = 3; const OUT_109: usize = 1; -fn aiur_fn_109(inp: [G; IN_109], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_109(inp: [G; IN_109], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_3]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_110: usize = 2; const IN_110: usize = 2; const OUT_110: usize = 1; -fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_5]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_3 - __v_1); let __v_6: G = G::from_bool((__v_5 == G::ZERO)); match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, (&__args[..]))?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { (*(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110])) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_110(inp: [G; IN_110], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_5]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_3 - __v_1; let __v_6: G = G::from_bool(__v_5 == G::ZERO); match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, &__args[..])?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_7]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_111: usize = 3; const IN_111: usize = 3; const OUT_111: usize = 1; -fn aiur_fn_111(inp: [G; IN_111], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_7]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = (__v_7 - __v_2); let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_11]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_21]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_23]; record.function_queries[111].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_111(inp: [G; IN_111], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_7]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = __v_7 - __v_2; let __v_10: G = G::from_bool(__v_9 == G::ZERO); match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_11]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_21]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_111] = [__v_23]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_112: usize = 3; const IN_112: usize = 3; const OUT_112: usize = 1; -fn aiur_fn_112(inp: [G; IN_112], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_7]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_10]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_20]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_22]; record.function_queries[112].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_112(inp: [G; IN_112], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_7]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_10]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_20]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_112] = [__v_22]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_113: usize = 2; const IN_113: usize = 2; const OUT_113: usize = 11; -fn aiur_fn_113(inp: [G; IN_113], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(256); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(65536); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(16777216); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(4294967296); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(1099511627776); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(281474976710656); let __v_23: G = (__v_22 * __v_9); let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = (__v_24 * __v_10); let __v_26: G = (__v_23 + __v_25); let __v_27: G = (__v_21 + __v_26); let __v_28: G = (__v_19 + __v_27); let __v_29: G = (__v_17 + __v_28); let __v_30: G = (__v_15 + __v_29); let __v_31: G = (__v_13 + __v_30); let __v_32: G = (__v_3 + __v_31); let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_33: G = G::from_u8(__gb[0]); let __v_34: G = G::from_u8(__gb[1]); let __v_35: G = G::from_u8(__gb[2]); let __v_36: G = G::from_u8(__gb[3]); let __v_37: G = G::from_u8(__gb[4]); let __v_38: G = G::from_u8(__gb[5]); let __v_39: G = G::from_u8(__gb[6]); let __v_40: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_41: G = (__v_12 * __v_34); let __v_42: G = (__v_14 * __v_35); let __v_43: G = (__v_16 * __v_36); let __v_44: G = (__v_18 * __v_37); let __v_45: G = (__v_20 * __v_38); let __v_46: G = (__v_22 * __v_39); let __v_47: G = (__v_24 * __v_40); let __v_48: G = (__v_46 + __v_47); let __v_49: G = (__v_45 + __v_48); let __v_50: G = (__v_44 + __v_49); let __v_51: G = (__v_43 + __v_50); let __v_52: G = (__v_42 + __v_51); let __v_53: G = (__v_41 + __v_52); let __v_54: G = (__v_33 + __v_53); if (__v_54 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_55: G = G::from_u64(1020); let __v_56: G = (__v_40 - __v_55); let __v_57: G = (__v_39 + __v_56); let __v_58: G = (__v_38 + __v_57); let __v_59: G = (__v_37 + __v_58); let __v_60: G = G::from_bool((__v_59 == G::ZERO)); let __v_61: G = (__v_35 + __v_36); let __v_62: G = (__v_34 + __v_61); let __v_63: G = (__v_33 + __v_62); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); let __v_65: G = G::from_u64(1); let __v_66: G = (__v_65 - __v_64); let __v_67: G = (__v_60 * __v_66); let __v_68: G = (__v_65 - __v_67); if (__v_68 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_113] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_65]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_0, __v_1, __v_15]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; let __v_23: G = __r_arr[8]; let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; let __ret: [G; OUT_113] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[113].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_113(inp: [G; IN_113], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(256); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(281474976710656); let __v_23: G = __v_22 * __v_9; let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = __v_24 * __v_10; let __v_26: G = __v_23 + __v_25; let __v_27: G = __v_21 + __v_26; let __v_28: G = __v_19 + __v_27; let __v_29: G = __v_17 + __v_28; let __v_30: G = __v_15 + __v_29; let __v_31: G = __v_13 + __v_30; let __v_32: G = __v_3 + __v_31; let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_33: G = G::from_u8(__gb[0]); let __v_34: G = G::from_u8(__gb[1]); let __v_35: G = G::from_u8(__gb[2]); let __v_36: G = G::from_u8(__gb[3]); let __v_37: G = G::from_u8(__gb[4]); let __v_38: G = G::from_u8(__gb[5]); let __v_39: G = G::from_u8(__gb[6]); let __v_40: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_41: G = __v_12 * __v_34; let __v_42: G = __v_14 * __v_35; let __v_43: G = __v_16 * __v_36; let __v_44: G = __v_18 * __v_37; let __v_45: G = __v_20 * __v_38; let __v_46: G = __v_22 * __v_39; let __v_47: G = __v_24 * __v_40; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_45 + __v_48; let __v_50: G = __v_44 + __v_49; let __v_51: G = __v_43 + __v_50; let __v_52: G = __v_42 + __v_51; let __v_53: G = __v_41 + __v_52; let __v_54: G = __v_33 + __v_53; if (__v_54 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_55: G = G::from_u64(1020); let __v_56: G = __v_40 - __v_55; let __v_57: G = __v_39 + __v_56; let __v_58: G = __v_38 + __v_57; let __v_59: G = __v_37 + __v_58; let __v_60: G = G::from_bool(__v_59 == G::ZERO); let __v_61: G = __v_35 + __v_36; let __v_62: G = __v_34 + __v_61; let __v_63: G = __v_33 + __v_62; let __v_64: G = G::from_bool(__v_63 == G::ZERO); let __v_65: G = G::from_u64(1); let __v_66: G = __v_65 - __v_64; let __v_67: G = __v_60 * __v_66; let __v_68: G = __v_65 - __v_67; if (__v_68 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_113] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_65]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_0, __v_1, __v_15]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; let __v_23: G = __r_arr[8]; let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; let __ret: [G; OUT_113] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_114: usize = 6; const IN_114: usize = 6; const OUT_114: usize = 1; -fn aiur_fn_114(inp: [G; IN_114], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = __r_arr[6]; let __v_13: G = __r_arr[7]; let __v_14: G = __r_arr[8]; let __v_15: G = __r_arr[9]; let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; let __v_29: G = __loaded[4]; let __v_30: G = __loaded[5]; let __v_31: G = __loaded[6]; let __v_32: G = __loaded[7]; let __v_33: G = __loaded[8]; let __v_34: G = __loaded[9]; let __v_35: G = __loaded[10]; let __v_36: G = __loaded[11]; let __v_37: G = __loaded[12]; let __v_38: G = __loaded[13]; let __v_39: G = __loaded[14]; let __v_40: G = __loaded[15]; let __v_41: G = __loaded[16]; let __v_42: G = __loaded[17]; let __v_43: G = __loaded[18]; let __v_44: G = __loaded[19]; let __v_45: G = __loaded[20]; let __v_46: G = __loaded[21]; let __v_47: G = __loaded[22]; let __v_48: G = __loaded[23]; let __v_49: G = __loaded[24]; let __v_50: G = __loaded[25]; let __v_51: G = __loaded[26]; let __v_52: G = __loaded[27]; let __v_53: G = __loaded[28]; let __v_54: G = __loaded[29]; let __v_55: G = __loaded[30]; let __v_56: G = __loaded[31]; let __v_57: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = G::from_u64(11); let __v_67: G = G::from_u64(103); let __v_68: G = G::from_u64(230); let __v_69: G = G::from_u64(9); let __v_70: G = G::from_u64(106); let __v_71: G = G::from_u64(133); let __v_72: G = G::from_u64(174); let __v_73: G = G::from_u64(187); let __v_74: G = G::from_u64(114); let __v_75: G = G::from_u64(243); let __v_76: G = G::from_u64(110); let __v_77: G = G::from_u64(60); let __v_78: G = G::from_u64(58); let __v_79: G = G::from_u64(245); let __v_80: G = G::from_u64(79); let __v_81: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_57, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_67, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_57, __v_57, __v_57, __v_57, __v_66, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; let __v_85: G = __r_arr[3]; let __v_86: G = __r_arr[4]; let __v_87: G = __r_arr[5]; let __v_88: G = __r_arr[6]; let __v_89: G = __r_arr[7]; let __v_90: G = __r_arr[8]; let __v_91: G = __r_arr[9]; let __v_92: G = __r_arr[10]; let __v_93: G = __r_arr[11]; let __v_94: G = __r_arr[12]; let __v_95: G = __r_arr[13]; let __v_96: G = __r_arr[14]; let __v_97: G = __r_arr[15]; let __v_98: G = __r_arr[16]; let __v_99: G = __r_arr[17]; let __v_100: G = __r_arr[18]; let __v_101: G = __r_arr[19]; let __v_102: G = __r_arr[20]; let __v_103: G = __r_arr[21]; let __v_104: G = __r_arr[22]; let __v_105: G = __r_arr[23]; let __v_106: G = __r_arr[24]; let __v_107: G = __r_arr[25]; let __v_108: G = __r_arr[26]; let __v_109: G = __r_arr[27]; let __v_110: G = __r_arr[28]; let __v_111: G = __r_arr[29]; let __v_112: G = __r_arr[30]; let __v_113: G = __r_arr[31]; let __v_114: G = { let __values: [G; 34] = [__v_57, __v_5, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_114]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, (&__args[..]))?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { (*(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113])) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; let __v_86: G = __r_arr[3]; let __v_87: G = __r_arr[4]; let __v_88: G = __r_arr[5]; let __v_89: G = __r_arr[6]; let __v_90: G = __r_arr[7]; let __v_91: G = __r_arr[8]; let __v_92: G = __r_arr[9]; let __v_93: G = __r_arr[10]; let __v_94: G = G::from_u64(8); let __v_95: G = (__v_82 + __v_93); let __v_96: G = (__v_71 + __v_95); let __v_97: G = (__v_60 + __v_96); let __v_98: G = (__v_49 + __v_97); let __v_99: G = (__v_38 + __v_98); let __v_100: G = (__v_27 + __v_99); let __v_101: G = (__v_16 + __v_100); let __v_102: G = (__v_94 * __v_101); let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; let __v_106: G = __loaded[3]; let __v_107: G = __loaded[4]; let __v_108: G = __loaded[5]; let __v_109: G = __loaded[6]; let __v_110: G = __loaded[7]; let __v_111: G = __loaded[8]; let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; match __v_113.as_canonical_u64() { 1u64 => { let __v_116: G = G::from_u64(1); break '__mc_0 [__v_116]; }, _ => { let __v_116: G = G::from_u64(0); break '__mc_0 [__v_116]; }, } }, _ => { let __v_113: G = G::from_u64(0); break '__mc_0 [__v_113]; }, } }; let __v_113: G = __mc_out___mc_0[0]; let __v_114: G = G::from_u64(15); let __v_115: G = (__v_2 - __v_114); let __v_116: G = G::from_bool((__v_115 == G::ZERO)); let __v_117: G = G::from_bool((__v_2 == G::ZERO)); let __v_118: G = (__v_113 * __v_116); let __v_119: G = (__v_116 - __v_118); let __v_120: G = (__v_113 + __v_119); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; let __v_124: G = __loaded[3]; let __v_125: G = __loaded[4]; let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, (&__args[..]))?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { (*(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2])) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_129: G = __r_arr[0]; let __v_130: G = (__v_113 * __v_129); let __v_131: G = G::from_u64(2); let __v_132: G = (__v_131 * __v_120); let __v_133: G = G::from_u64(8); let __v_134: G = (__v_133 * __v_130); let __v_135: G = (__v_132 + __v_134); let __v_136: G = (__v_117 + __v_135); let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; let __v_140: G = __loaded[3]; let __v_141: G = __loaded[4]; let __v_142: G = __loaded[5]; let __v_143: G = __loaded[6]; let __v_144: G = __loaded[7]; let __v_145: G = __loaded[8]; let __v_146: G = __loaded[9]; let __v_147: G = __loaded[10]; let __v_148: G = __loaded[11]; let __v_149: G = __loaded[12]; let __v_150: G = __loaded[13]; let __v_151: G = __loaded[14]; let __v_152: G = __loaded[15]; let __v_153: G = __loaded[16]; let __v_154: G = __loaded[17]; let __v_155: G = __loaded[18]; let __v_156: G = __loaded[19]; let __v_157: G = __loaded[20]; let __v_158: G = __loaded[21]; let __v_159: G = __loaded[22]; let __v_160: G = __loaded[23]; let __v_161: G = __loaded[24]; let __v_162: G = __loaded[25]; let __v_163: G = __loaded[26]; let __v_164: G = __loaded[27]; let __v_165: G = __loaded[28]; let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; let __v_169: G = G::from_u64(103); let __v_170: G = G::from_u64(230); let __v_171: G = G::from_u64(9); let __v_172: G = G::from_u64(106); let __v_173: G = G::from_u64(133); let __v_174: G = G::from_u64(174); let __v_175: G = G::from_u64(187); let __v_176: G = G::from_u64(114); let __v_177: G = G::from_u64(243); let __v_178: G = G::from_u64(110); let __v_179: G = G::from_u64(60); let __v_180: G = G::from_u64(58); let __v_181: G = G::from_u64(245); let __v_182: G = G::from_u64(79); let __v_183: G = G::from_u64(165); let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_184, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_169, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_102, __v_184, __v_184, __v_184, __v_136, __v_184, __v_184, __v_184, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, (&__args[..]))?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { (*(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83])) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __v_188: G = __r_arr[3]; let __v_189: G = __r_arr[4]; let __v_190: G = __r_arr[5]; let __v_191: G = __r_arr[6]; let __v_192: G = __r_arr[7]; let __v_193: G = __r_arr[8]; let __v_194: G = __r_arr[9]; let __v_195: G = __r_arr[10]; let __v_196: G = __r_arr[11]; let __v_197: G = __r_arr[12]; let __v_198: G = __r_arr[13]; let __v_199: G = __r_arr[14]; let __v_200: G = __r_arr[15]; let __v_201: G = __r_arr[16]; let __v_202: G = __r_arr[17]; let __v_203: G = __r_arr[18]; let __v_204: G = __r_arr[19]; let __v_205: G = __r_arr[20]; let __v_206: G = __r_arr[21]; let __v_207: G = __r_arr[22]; let __v_208: G = __r_arr[23]; let __v_209: G = __r_arr[24]; let __v_210: G = __r_arr[25]; let __v_211: G = __r_arr[26]; let __v_212: G = __r_arr[27]; let __v_213: G = __r_arr[28]; let __v_214: G = __r_arr[29]; let __v_215: G = __r_arr[30]; let __v_216: G = __r_arr[31]; match __v_113.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(0); let __v_218: G = { let __values: [G; 34] = [__v_217, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_218]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { match __v_116.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(103); let __v_218: G = G::from_u64(230); let __v_219: G = G::from_u64(9); let __v_220: G = G::from_u64(106); let __v_221: G = G::from_u64(133); let __v_222: G = G::from_u64(174); let __v_223: G = G::from_u64(187); let __v_224: G = G::from_u64(114); let __v_225: G = G::from_u64(243); let __v_226: G = G::from_u64(110); let __v_227: G = G::from_u64(60); let __v_228: G = G::from_u64(58); let __v_229: G = G::from_u64(245); let __v_230: G = G::from_u64(79); let __v_231: G = G::from_u64(165); let __v_232: G = G::from_u64(127); let __v_233: G = G::from_u64(82); let __v_234: G = G::from_u64(14); let __v_235: G = G::from_u64(81); let __v_236: G = G::from_u64(140); let __v_237: G = G::from_u64(104); let __v_238: G = G::from_u64(5); let __v_239: G = G::from_u64(155); let __v_240: G = G::from_u64(171); let __v_241: G = G::from_u64(217); let __v_242: G = G::from_u64(131); let __v_243: G = G::from_u64(31); let __v_244: G = G::from_u64(25); let __v_245: G = G::from_u64(205); let __v_246: G = G::from_u64(224); let __v_247: G = G::from_u64(91); let __v_248: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_249: G = __loaded[0]; let __v_250: G = __loaded[1]; let __v_251: G = __loaded[2]; let __v_252: G = __loaded[3]; let __v_253: G = __loaded[4]; let __v_254: G = __loaded[5]; let __v_255: G = __loaded[6]; let __v_256: G = __loaded[7]; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, (&__args[..]))?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { (*(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11])) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_257: G = __r_arr[0]; let __v_258: G = __r_arr[1]; let __v_259: G = __r_arr[2]; let __v_260: G = __r_arr[3]; let __v_261: G = __r_arr[4]; let __v_262: G = __r_arr[5]; let __v_263: G = __r_arr[6]; let __v_264: G = __r_arr[7]; let __v_265: G = { let __values: [G; 8] = [__v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_266: G = { let __values: [G; 32] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_217, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_267: G = { let __values: [G; 34] = [__v_248, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_268: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_268]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_217: G = G::from_u64(1); let __v_218: G = (__v_2 + __v_217); let __v_219: G = { let __values: [G; 32] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_220]; record.function_queries[114].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }) } +fn aiur_fn_114(inp: [G; IN_114], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = __r_arr[6]; let __v_13: G = __r_arr[7]; let __v_14: G = __r_arr[8]; let __v_15: G = __r_arr[9]; let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; match __v_17.as_canonical_u64() { 0u64 => { match __v_18.as_canonical_u64() { 0u64 => { match __v_19.as_canonical_u64() { 0u64 => { match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { match __v_22.as_canonical_u64() { 0u64 => { match __v_23.as_canonical_u64() { 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; let __v_29: G = __loaded[4]; let __v_30: G = __loaded[5]; let __v_31: G = __loaded[6]; let __v_32: G = __loaded[7]; let __v_33: G = __loaded[8]; let __v_34: G = __loaded[9]; let __v_35: G = __loaded[10]; let __v_36: G = __loaded[11]; let __v_37: G = __loaded[12]; let __v_38: G = __loaded[13]; let __v_39: G = __loaded[14]; let __v_40: G = __loaded[15]; let __v_41: G = __loaded[16]; let __v_42: G = __loaded[17]; let __v_43: G = __loaded[18]; let __v_44: G = __loaded[19]; let __v_45: G = __loaded[20]; let __v_46: G = __loaded[21]; let __v_47: G = __loaded[22]; let __v_48: G = __loaded[23]; let __v_49: G = __loaded[24]; let __v_50: G = __loaded[25]; let __v_51: G = __loaded[26]; let __v_52: G = __loaded[27]; let __v_53: G = __loaded[28]; let __v_54: G = __loaded[29]; let __v_55: G = __loaded[30]; let __v_56: G = __loaded[31]; let __v_57: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = G::from_u64(11); let __v_67: G = G::from_u64(103); let __v_68: G = G::from_u64(230); let __v_69: G = G::from_u64(9); let __v_70: G = G::from_u64(106); let __v_71: G = G::from_u64(133); let __v_72: G = G::from_u64(174); let __v_73: G = G::from_u64(187); let __v_74: G = G::from_u64(114); let __v_75: G = G::from_u64(243); let __v_76: G = G::from_u64(110); let __v_77: G = G::from_u64(60); let __v_78: G = G::from_u64(58); let __v_79: G = G::from_u64(245); let __v_80: G = G::from_u64(79); let __v_81: G = G::from_u64(165); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_57, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_67, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_57, __v_57, __v_57, __v_57, __v_66, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; let __v_85: G = __r_arr[3]; let __v_86: G = __r_arr[4]; let __v_87: G = __r_arr[5]; let __v_88: G = __r_arr[6]; let __v_89: G = __r_arr[7]; let __v_90: G = __r_arr[8]; let __v_91: G = __r_arr[9]; let __v_92: G = __r_arr[10]; let __v_93: G = __r_arr[11]; let __v_94: G = __r_arr[12]; let __v_95: G = __r_arr[13]; let __v_96: G = __r_arr[14]; let __v_97: G = __r_arr[15]; let __v_98: G = __r_arr[16]; let __v_99: G = __r_arr[17]; let __v_100: G = __r_arr[18]; let __v_101: G = __r_arr[19]; let __v_102: G = __r_arr[20]; let __v_103: G = __r_arr[21]; let __v_104: G = __r_arr[22]; let __v_105: G = __r_arr[23]; let __v_106: G = __r_arr[24]; let __v_107: G = __r_arr[25]; let __v_108: G = __r_arr[26]; let __v_109: G = __r_arr[27]; let __v_110: G = __r_arr[28]; let __v_111: G = __r_arr[29]; let __v_112: G = __r_arr[30]; let __v_113: G = __r_arr[31]; let __v_114: G = { let __values: [G; 34] = [__v_57, __v_5, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_114]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_114] = [__v_5]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; let __v_53: G = __r_arr[3]; let __v_54: G = __r_arr[4]; let __v_55: G = __r_arr[5]; let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_80, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(113, &__args[..])?) { [G::ZERO; OUT_113] } else { let (__hash, __hit) = record.function_queries[113].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[113].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => { aiur_fn_113::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; let __v_86: G = __r_arr[3]; let __v_87: G = __r_arr[4]; let __v_88: G = __r_arr[5]; let __v_89: G = __r_arr[6]; let __v_90: G = __r_arr[7]; let __v_91: G = __r_arr[8]; let __v_92: G = __r_arr[9]; let __v_93: G = __r_arr[10]; let __v_94: G = G::from_u64(8); let __v_95: G = __v_82 + __v_93; let __v_96: G = __v_71 + __v_95; let __v_97: G = __v_60 + __v_96; let __v_98: G = __v_49 + __v_97; let __v_99: G = __v_38 + __v_98; let __v_100: G = __v_27 + __v_99; let __v_101: G = __v_16 + __v_100; let __v_102: G = __v_94 * __v_101; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; let __v_106: G = __loaded[3]; let __v_107: G = __loaded[4]; let __v_108: G = __loaded[5]; let __v_109: G = __loaded[6]; let __v_110: G = __loaded[7]; let __v_111: G = __loaded[8]; let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; match __v_113.as_canonical_u64() { 1u64 => { let __v_116: G = G::from_u64(1); break '__mc_0 [__v_116]; }, _ => { let __v_116: G = G::from_u64(0); break '__mc_0 [__v_116]; }, } }, _ => { let __v_113: G = G::from_u64(0); break '__mc_0 [__v_113]; }, } }; let __v_113: G = __mc_out___mc_0[0]; let __v_114: G = G::from_u64(15); let __v_115: G = __v_2 - __v_114; let __v_116: G = G::from_bool(__v_115 == G::ZERO); let __v_117: G = G::from_bool(__v_2 == G::ZERO); let __v_118: G = __v_113 * __v_116; let __v_119: G = __v_116 - __v_118; let __v_120: G = __v_113 + __v_119; let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; let __v_124: G = __loaded[3]; let __v_125: G = __loaded[4]; let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(2, &__args[..])?) { [G::ZERO; OUT_2] } else { let (__hash, __hit) = record.function_queries[2].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[2].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => { aiur_fn_2::(__args, __hash, record, io_buffer)? }, } } }; let __v_129: G = __r_arr[0]; let __v_130: G = __v_113 * __v_129; let __v_131: G = G::from_u64(2); let __v_132: G = __v_131 * __v_120; let __v_133: G = G::from_u64(8); let __v_134: G = __v_133 * __v_130; let __v_135: G = __v_132 + __v_134; let __v_136: G = __v_117 + __v_135; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; let __v_140: G = __loaded[3]; let __v_141: G = __loaded[4]; let __v_142: G = __loaded[5]; let __v_143: G = __loaded[6]; let __v_144: G = __loaded[7]; let __v_145: G = __loaded[8]; let __v_146: G = __loaded[9]; let __v_147: G = __loaded[10]; let __v_148: G = __loaded[11]; let __v_149: G = __loaded[12]; let __v_150: G = __loaded[13]; let __v_151: G = __loaded[14]; let __v_152: G = __loaded[15]; let __v_153: G = __loaded[16]; let __v_154: G = __loaded[17]; let __v_155: G = __loaded[18]; let __v_156: G = __loaded[19]; let __v_157: G = __loaded[20]; let __v_158: G = __loaded[21]; let __v_159: G = __loaded[22]; let __v_160: G = __loaded[23]; let __v_161: G = __loaded[24]; let __v_162: G = __loaded[25]; let __v_163: G = __loaded[26]; let __v_164: G = __loaded[27]; let __v_165: G = __loaded[28]; let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; let __v_169: G = G::from_u64(103); let __v_170: G = G::from_u64(230); let __v_171: G = G::from_u64(9); let __v_172: G = G::from_u64(106); let __v_173: G = G::from_u64(133); let __v_174: G = G::from_u64(174); let __v_175: G = G::from_u64(187); let __v_176: G = G::from_u64(114); let __v_177: G = G::from_u64(243); let __v_178: G = G::from_u64(110); let __v_179: G = G::from_u64(60); let __v_180: G = G::from_u64(58); let __v_181: G = G::from_u64(245); let __v_182: G = G::from_u64(79); let __v_183: G = G::from_u64(165); let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_184, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_169, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_102, __v_184, __v_184, __v_184, __v_136, __v_184, __v_184, __v_184, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(83, &__args[..])?) { [G::ZERO; OUT_83] } else { let (__hash, __hit) = record.function_queries[83].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[83].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => { aiur_fn_83::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; let __v_188: G = __r_arr[3]; let __v_189: G = __r_arr[4]; let __v_190: G = __r_arr[5]; let __v_191: G = __r_arr[6]; let __v_192: G = __r_arr[7]; let __v_193: G = __r_arr[8]; let __v_194: G = __r_arr[9]; let __v_195: G = __r_arr[10]; let __v_196: G = __r_arr[11]; let __v_197: G = __r_arr[12]; let __v_198: G = __r_arr[13]; let __v_199: G = __r_arr[14]; let __v_200: G = __r_arr[15]; let __v_201: G = __r_arr[16]; let __v_202: G = __r_arr[17]; let __v_203: G = __r_arr[18]; let __v_204: G = __r_arr[19]; let __v_205: G = __r_arr[20]; let __v_206: G = __r_arr[21]; let __v_207: G = __r_arr[22]; let __v_208: G = __r_arr[23]; let __v_209: G = __r_arr[24]; let __v_210: G = __r_arr[25]; let __v_211: G = __r_arr[26]; let __v_212: G = __r_arr[27]; let __v_213: G = __r_arr[28]; let __v_214: G = __r_arr[29]; let __v_215: G = __r_arr[30]; let __v_216: G = __r_arr[31]; match __v_113.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(0); let __v_218: G = { let __values: [G; 34] = [__v_217, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_114] = [__v_218]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_116.as_canonical_u64() { 1u64 => { let __v_217: G = G::from_u64(103); let __v_218: G = G::from_u64(230); let __v_219: G = G::from_u64(9); let __v_220: G = G::from_u64(106); let __v_221: G = G::from_u64(133); let __v_222: G = G::from_u64(174); let __v_223: G = G::from_u64(187); let __v_224: G = G::from_u64(114); let __v_225: G = G::from_u64(243); let __v_226: G = G::from_u64(110); let __v_227: G = G::from_u64(60); let __v_228: G = G::from_u64(58); let __v_229: G = G::from_u64(245); let __v_230: G = G::from_u64(79); let __v_231: G = G::from_u64(165); let __v_232: G = G::from_u64(127); let __v_233: G = G::from_u64(82); let __v_234: G = G::from_u64(14); let __v_235: G = G::from_u64(81); let __v_236: G = G::from_u64(140); let __v_237: G = G::from_u64(104); let __v_238: G = G::from_u64(5); let __v_239: G = G::from_u64(155); let __v_240: G = G::from_u64(171); let __v_241: G = G::from_u64(217); let __v_242: G = G::from_u64(131); let __v_243: G = G::from_u64(31); let __v_244: G = G::from_u64(25); let __v_245: G = G::from_u64(205); let __v_246: G = G::from_u64(224); let __v_247: G = G::from_u64(91); let __v_248: G = G::from_u64(0); let __loaded: [G; 8] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_249: G = __loaded[0]; let __v_250: G = __loaded[1]; let __v_251: G = __loaded[2]; let __v_252: G = __loaded[3]; let __v_253: G = __loaded[4]; let __v_254: G = __loaded[5]; let __v_255: G = __loaded[6]; let __v_256: G = __loaded[7]; let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(11, &__args[..])?) { [G::ZERO; OUT_11] } else { let (__hash, __hit) = record.function_queries[11].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[11].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[11].bump_multiplicity(__i); } let __ret: [G; OUT_11] = unsafe { *(record.function_queries[11].output_at(__i).as_ptr() as *const [G; OUT_11]) }; __ret }, _ => { aiur_fn_11::(__args, __hash, record, io_buffer)? }, } } }; let __v_257: G = __r_arr[0]; let __v_258: G = __r_arr[1]; let __v_259: G = __r_arr[2]; let __v_260: G = __r_arr[3]; let __v_261: G = __r_arr[4]; let __v_262: G = __r_arr[5]; let __v_263: G = __r_arr[6]; let __v_264: G = __r_arr[7]; let __v_265: G = { let __values: [G; 8] = [__v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_266: G = { let __values: [G; 32] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_217, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_267: G = { let __values: [G; 34] = [__v_248, __v_5, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_268: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_268]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_217: G = G::from_u64(1); let __v_218: G = __v_2 + __v_217; let __v_219: G = { let __values: [G; 32] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_220]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } const INPUT_SIZE_115: usize = 1; const IN_115: usize = 1; const OUT_115: usize = 32; -fn aiur_fn_115(inp: [G; IN_115], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 10] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_115] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[115].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_115(inp: [G; IN_115], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(106); let __v_5: G = G::from_u64(133); let __v_6: G = G::from_u64(174); let __v_7: G = G::from_u64(187); let __v_8: G = G::from_u64(114); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(110); let __v_11: G = G::from_u64(60); let __v_12: G = G::from_u64(58); let __v_13: G = G::from_u64(245); let __v_14: G = G::from_u64(79); let __v_15: G = G::from_u64(165); let __v_16: G = G::from_u64(127); let __v_17: G = G::from_u64(82); let __v_18: G = G::from_u64(14); let __v_19: G = G::from_u64(81); let __v_20: G = G::from_u64(140); let __v_21: G = G::from_u64(104); let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(155); let __v_24: G = G::from_u64(171); let __v_25: G = G::from_u64(217); let __v_26: G = G::from_u64(131); let __v_27: G = G::from_u64(31); let __v_28: G = G::from_u64(25); let __v_29: G = G::from_u64(205); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(91); let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 10] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 8] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 34] = [__v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __v_42: G = __r_arr[3]; let __v_43: G = __r_arr[4]; let __v_44: G = __r_arr[5]; let __v_45: G = __r_arr[6]; let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; let __v_50: G = __r_arr[11]; let __v_51: G = __r_arr[12]; let __v_52: G = __r_arr[13]; let __v_53: G = __r_arr[14]; let __v_54: G = __r_arr[15]; let __v_55: G = __r_arr[16]; let __v_56: G = __r_arr[17]; let __v_57: G = __r_arr[18]; let __v_58: G = __r_arr[19]; let __v_59: G = __r_arr[20]; let __v_60: G = __r_arr[21]; let __v_61: G = __r_arr[22]; let __v_62: G = __r_arr[23]; let __v_63: G = __r_arr[24]; let __v_64: G = __r_arr[25]; let __v_65: G = __r_arr[26]; let __v_66: G = __r_arr[27]; let __v_67: G = __r_arr[28]; let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __ret: [G; OUT_115] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_116: usize = 3; const IN_116: usize = 3; const OUT_116: usize = 1; -fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, (&__args[..]))?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { (*(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111])) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(174); let __v_10: G = G::from_u64(187); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(243); let __v_13: G = G::from_u64(110); let __v_14: G = G::from_u64(60); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(245); let __v_17: G = G::from_u64(79); let __v_18: G = G::from_u64(165); let __v_19: G = G::from_u64(127); let __v_20: G = G::from_u64(82); let __v_21: G = G::from_u64(14); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(140); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(217); let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(31); let __v_31: G = G::from_u64(25); let __v_32: G = G::from_u64(205); let __v_33: G = G::from_u64(224); let __v_34: G = G::from_u64(91); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 10] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 8] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_4, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 34] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, (&__args[..]))?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { (*(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114])) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; let __v_45: G = __r_arr[3]; let __v_46: G = __r_arr[4]; let __v_47: G = __r_arr[5]; let __v_48: G = __r_arr[6]; let __v_49: G = __r_arr[7]; let __v_50: G = __r_arr[8]; let __v_51: G = __r_arr[9]; let __v_52: G = __r_arr[10]; let __v_53: G = __r_arr[11]; let __v_54: G = __r_arr[12]; let __v_55: G = __r_arr[13]; let __v_56: G = __r_arr[14]; let __v_57: G = __r_arr[15]; let __v_58: G = __r_arr[16]; let __v_59: G = __r_arr[17]; let __v_60: G = __r_arr[18]; let __v_61: G = __r_arr[19]; let __v_62: G = __r_arr[20]; let __v_63: G = __r_arr[21]; let __v_64: G = __r_arr[22]; let __v_65: G = __r_arr[23]; let __v_66: G = __r_arr[24]; let __v_67: G = __r_arr[25]; let __v_68: G = __r_arr[26]; let __v_69: G = __r_arr[27]; let __v_70: G = __r_arr[28]; let __v_71: G = __r_arr[29]; let __v_72: G = __r_arr[30]; let __v_73: G = __r_arr[31]; let __v_74: G = { let __values: [G; 32] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_116] = [__v_74]; record.function_queries[116].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_116(inp: [G; IN_116], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(111, &__args[..])?) { [G::ZERO; OUT_111] } else { let (__hash, __hit) = record.function_queries[111].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[111].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => { aiur_fn_111::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); let __v_6: G = G::from_u64(9); let __v_7: G = G::from_u64(106); let __v_8: G = G::from_u64(133); let __v_9: G = G::from_u64(174); let __v_10: G = G::from_u64(187); let __v_11: G = G::from_u64(114); let __v_12: G = G::from_u64(243); let __v_13: G = G::from_u64(110); let __v_14: G = G::from_u64(60); let __v_15: G = G::from_u64(58); let __v_16: G = G::from_u64(245); let __v_17: G = G::from_u64(79); let __v_18: G = G::from_u64(165); let __v_19: G = G::from_u64(127); let __v_20: G = G::from_u64(82); let __v_21: G = G::from_u64(14); let __v_22: G = G::from_u64(81); let __v_23: G = G::from_u64(140); let __v_24: G = G::from_u64(104); let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(155); let __v_27: G = G::from_u64(171); let __v_28: G = G::from_u64(217); let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(31); let __v_31: G = G::from_u64(25); let __v_32: G = G::from_u64(205); let __v_33: G = G::from_u64(224); let __v_34: G = G::from_u64(91); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 10] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 8] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_4, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 34] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(114, &__args[..])?) { [G::ZERO; OUT_114] } else { let (__hash, __hit) = record.function_queries[114].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[114].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => { aiur_fn_114::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; let __v_45: G = __r_arr[3]; let __v_46: G = __r_arr[4]; let __v_47: G = __r_arr[5]; let __v_48: G = __r_arr[6]; let __v_49: G = __r_arr[7]; let __v_50: G = __r_arr[8]; let __v_51: G = __r_arr[9]; let __v_52: G = __r_arr[10]; let __v_53: G = __r_arr[11]; let __v_54: G = __r_arr[12]; let __v_55: G = __r_arr[13]; let __v_56: G = __r_arr[14]; let __v_57: G = __r_arr[15]; let __v_58: G = __r_arr[16]; let __v_59: G = __r_arr[17]; let __v_60: G = __r_arr[18]; let __v_61: G = __r_arr[19]; let __v_62: G = __r_arr[20]; let __v_63: G = __r_arr[21]; let __v_64: G = __r_arr[22]; let __v_65: G = __r_arr[23]; let __v_66: G = __r_arr[24]; let __v_67: G = __r_arr[25]; let __v_68: G = __r_arr[26]; let __v_69: G = __r_arr[27]; let __v_70: G = __r_arr[28]; let __v_71: G = __r_arr[29]; let __v_72: G = __r_arr[30]; let __v_73: G = __r_arr[31]; let __v_74: G = { let __values: [G; 32] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_116] = [__v_74]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_117: usize = 4; const IN_117: usize = 4; const OUT_117: usize = 1; -fn aiur_fn_117(inp: [G; IN_117], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, (&__args[..]))?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { (*(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110])) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_117] = [__v_3]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_6]; record.function_queries[117].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_117(inp: [G; IN_117], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(110, &__args[..])?) { [G::ZERO; OUT_110] } else { let (__hash, __hit) = record.function_queries[110].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[110].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => { aiur_fn_110::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_117] = [__v_3]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_6]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_118: usize = 1; const IN_118: usize = 1; const OUT_118: usize = 1; -fn aiur_fn_118(inp: [G; IN_118], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_118] = [__v_4]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_118] = [__v_7]; record.function_queries[118].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_118(inp: [G; IN_118], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_118] = [__v_4]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_4 * __v_5; let __v_7: G = __v_2 + __v_6; let __ret: [G; OUT_118] = [__v_7]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_119: usize = 2; const IN_119: usize = 2; const OUT_119: usize = 1; -fn aiur_fn_119(inp: [G; IN_119], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_1]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_0]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { match __v_9.as_canonical_u64() { _ => { let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, (&__args[..]))?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { (*(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0])) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_17]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = (__v_3 - __v_9); let __v_16: G = G::from_bool((__v_15 == G::ZERO)); match __v_16.as_canonical_u64() { 1u64 => { if (__v_6 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_119(inp: [G; IN_119], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_1]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_0]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { match __v_9.as_canonical_u64() { _ => { let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(0, &__args[..])?) { [G::ZERO; OUT_0] } else { let (__hash, __hit) = record.function_queries[0].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[0].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => { aiur_fn_0::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_17]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = __v_3 - __v_9; let __v_16: G = G::from_bool(__v_15 == G::ZERO); match __v_16.as_canonical_u64() { 1u64 => { if (__v_6 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_119] = [__v_19]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_120: usize = 1; const IN_120: usize = 1; const OUT_120: usize = 2; -fn aiur_fn_120(inp: [G; IN_120], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 6] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_8, __v_8]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 6] = [__v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_15]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_15]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_17]; record.function_queries[120].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_120(inp: [G; IN_120], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 6] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_8, __v_8]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 6] = [__v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_15]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_15]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_120] = [__v_16, __v_17]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_121: usize = 1; const IN_121: usize = 1; const OUT_121: usize = 1; -fn aiur_fn_121(inp: [G; IN_121], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_121] = [__v_0]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_121] = [__v_0]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, (&__args[..]))?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { (*(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120])) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, (&__args[..]))?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { (*(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119])) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_17]; record.function_queries[121].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_121(inp: [G; IN_121], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_121] = [__v_0]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_121] = [__v_0]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(120, &__args[..])?) { [G::ZERO; OUT_120] } else { let (__hash, __hit) = record.function_queries[120].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[120].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => { aiur_fn_120::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(119, &__args[..])?) { [G::ZERO; OUT_119] } else { let (__hash, __hit) = record.function_queries[119].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[119].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => { aiur_fn_119::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_17]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_122: usize = 4; const IN_122: usize = 4; const OUT_122: usize = 1; -fn aiur_fn_122(inp: [G; IN_122], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 6] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_10]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, (&__args[..]))?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { (*(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116])) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_14]; record.function_queries[122].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_122(inp: [G; IN_122], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 6] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_10]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(116, &__args[..])?) { [G::ZERO; OUT_116] } else { let (__hash, __hit) = record.function_queries[116].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[116].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => { aiur_fn_116::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_122] = [__v_14]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_123: usize = 4; const IN_123: usize = 4; const OUT_123: usize = 2; -fn aiur_fn_123(inp: [G; IN_123], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 6] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_11, __v_1]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_13 - __v_23); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); match __v_25.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, (&__args[..]))?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { (*(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112])) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, (&__args[..]))?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { (*(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108])) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_29, __v_30]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_33, __v_31]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, (&__args[..]))?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { (*(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109])) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_34, __v_32]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, } }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, (&__args[..]))?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { (*(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109])) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, (&__args[..]))?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { (*(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117])) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 6] = [__v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_27]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 6)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_28, __v_22]; record.function_queries[123].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_123(inp: [G; IN_123], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 6] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_11, __v_1]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __v_13 - __v_23; let __v_25: G = G::from_bool(__v_24 == G::ZERO); match __v_25.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(112, &__args[..])?) { [G::ZERO; OUT_112] } else { let (__hash, __hit) = record.function_queries[112].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[112].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => { aiur_fn_112::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(108, &__args[..])?) { [G::ZERO; OUT_108] } else { let (__hash, __hit) = record.function_queries[108].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[108].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => { aiur_fn_108::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_29, __v_30]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_33, __v_31]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, &__args[..])?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_34, __v_32]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, } }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(109, &__args[..])?) { [G::ZERO; OUT_109] } else { let (__hash, __hit) = record.function_queries[109].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[109].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => { aiur_fn_109::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(117, &__args[..])?) { [G::ZERO; OUT_117] } else { let (__hash, __hit) = record.function_queries[117].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[117].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => { aiur_fn_117::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 6] = [__v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_27]; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 6)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_123] = [__v_28, __v_22]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_124: usize = 4; const IN_124: usize = 4; const OUT_124: usize = 2; -fn aiur_fn_124(inp: [G; IN_124], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_124] = [__v_0, __v_1]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_3 - __v_4); let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, (&__args[..]))?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { (*(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123])) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6, __v_7, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_124] = [__v_8, __v_9]; record.function_queries[124].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_124(inp: [G; IN_124], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_124] = [__v_0, __v_1]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_3 - __v_4; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(123, &__args[..])?) { [G::ZERO; OUT_123] } else { let (__hash, __hit) = record.function_queries[123].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[123].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => { aiur_fn_123::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6, __v_7, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_124] = [__v_8, __v_9]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_125: usize = 6; const IN_125: usize = 6; const OUT_125: usize = 1; -fn aiur_fn_125(inp: [G; IN_125], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, (&__args[..]))?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { (*(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122])) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, (&__args[..]))?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { (*(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121])) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_12, __v_4, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, (&__args[..]))?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { (*(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124])) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_21); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __ret: [G; OUT_125] = [__v_27]; record.function_queries[125].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } +fn aiur_fn_125(inp: [G; IN_125], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; let __v_9: G = G::from_bool(__v_8 == G::ZERO); let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(122, &__args[..])?) { [G::ZERO; OUT_122] } else { let (__hash, __hit) = record.function_queries[122].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[122].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => { aiur_fn_122::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(121, &__args[..])?) { [G::ZERO; OUT_121] } else { let (__hash, __hit) = record.function_queries[121].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[121].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => { aiur_fn_121::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_12, __v_4, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(124, &__args[..])?) { [G::ZERO; OUT_124] } else { let (__hash, __hit) = record.function_queries[124].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[124].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => { aiur_fn_124::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __v_25 - __v_21; let __v_27: G = G::from_bool(__v_26 == G::ZERO); let __ret: [G; OUT_125] = [__v_27]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } const INPUT_SIZE_126: usize = 2; const IN_126: usize = 2; const OUT_126: usize = 1; -fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_126] = [__v_1]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_7]; record.function_queries[126].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_126(inp: [G; IN_126], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_126] = [__v_1]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_7]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_127: usize = 2; const IN_127: usize = 2; const OUT_127: usize = 1; -fn aiur_fn_127(inp: [G; IN_127], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_127] = [__v_5]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_6]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); let __ret: [G; OUT_127] = [__v_7]; record.function_queries[127].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_127(inp: [G; IN_127], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_127] = [__v_5]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_0 * __v_0; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_6]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = __v_0 * __v_6; let __ret: [G; OUT_127] = [__v_7]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_128: usize = 8; const IN_128: usize = 8; const OUT_128: usize = 2; -fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_13); let __v_15: G = (__v_4 + __v_6); let __v_16: G = (__v_5 + __v_7); let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __v_19: G = (__v_17 * __v_17); let __v_20: G = G::from_u64(7); let __v_21: G = (__v_18 * __v_18); let __v_22: G = (__v_20 * __v_21); let __v_23: G = (__v_19 - __v_22); let __v_24: G = aiur::execute::g_inverse_value(__v_23); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_25 - __v_8); let __v_27: G = (__v_23 * __v_26); if (__v_27 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_28: G = (__v_24 * __v_26); if (__v_28 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_29: G = (__v_17 * __v_24); let __v_30: G = (__v_18 - __v_18); let __v_31: G = (__v_30 * __v_24); let __v_32: G = (__v_15 * __v_29); let __v_33: G = (__v_16 * __v_31); let __v_34: G = (__v_20 * __v_33); let __v_35: G = (__v_32 + __v_34); let __v_36: G = (__v_15 * __v_31); let __v_37: G = (__v_16 * __v_29); let __v_38: G = (__v_36 + __v_37); let __v_39: G = (__v_4 - __v_6); let __v_40: G = (__v_5 - __v_7); let __v_41: G = (__v_14 * __v_14); let __v_42: G = (__v_41 - __v_22); let __v_43: G = aiur::execute::g_inverse_value(__v_42); let __v_44: G = (__v_42 * __v_43); let __v_45: G = (__v_44 - __v_8); let __v_46: G = (__v_42 * __v_45); if (__v_46 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_47: G = (__v_43 * __v_45); if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_48: G = (__v_14 * __v_43); let __v_49: G = (__v_30 * __v_43); let __v_50: G = (__v_39 * __v_48); let __v_51: G = (__v_40 * __v_49); let __v_52: G = (__v_20 * __v_51); let __v_53: G = (__v_50 + __v_52); let __v_54: G = (__v_39 * __v_49); let __v_55: G = (__v_40 * __v_48); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_2 * __v_53); let __v_58: G = (__v_3 * __v_56); let __v_59: G = (__v_20 * __v_58); let __v_60: G = (__v_57 + __v_59); let __v_61: G = (__v_2 * __v_56); let __v_62: G = (__v_3 * __v_53); let __v_63: G = (__v_61 + __v_62); let __v_64: G = (__v_35 + __v_60); let __v_65: G = (__v_38 + __v_63); let __ret: [G; OUT_128] = [__v_64, __v_65]; record.function_queries[128].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_128(inp: [G; IN_128], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 + __v_8; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_13; let __v_15: G = __v_4 + __v_6; let __v_16: G = __v_5 + __v_7; let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __v_19: G = __v_17 * __v_17; let __v_20: G = G::from_u64(7); let __v_21: G = __v_18 * __v_18; let __v_22: G = __v_20 * __v_21; let __v_23: G = __v_19 - __v_22; let __v_24: G = aiur::execute::g_inverse_value(__v_23); let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_25 - __v_8; let __v_27: G = __v_23 * __v_26; if (__v_27 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_28: G = __v_24 * __v_26; if (__v_28 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_29: G = __v_17 * __v_24; let __v_30: G = __v_18 - __v_18; let __v_31: G = __v_30 * __v_24; let __v_32: G = __v_15 * __v_29; let __v_33: G = __v_16 * __v_31; let __v_34: G = __v_20 * __v_33; let __v_35: G = __v_32 + __v_34; let __v_36: G = __v_15 * __v_31; let __v_37: G = __v_16 * __v_29; let __v_38: G = __v_36 + __v_37; let __v_39: G = __v_4 - __v_6; let __v_40: G = __v_5 - __v_7; let __v_41: G = __v_14 * __v_14; let __v_42: G = __v_41 - __v_22; let __v_43: G = aiur::execute::g_inverse_value(__v_42); let __v_44: G = __v_42 * __v_43; let __v_45: G = __v_44 - __v_8; let __v_46: G = __v_42 * __v_45; if (__v_46 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_47: G = __v_43 * __v_45; if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_48: G = __v_14 * __v_43; let __v_49: G = __v_30 * __v_43; let __v_50: G = __v_39 * __v_48; let __v_51: G = __v_40 * __v_49; let __v_52: G = __v_20 * __v_51; let __v_53: G = __v_50 + __v_52; let __v_54: G = __v_39 * __v_49; let __v_55: G = __v_40 * __v_48; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_2 * __v_53; let __v_58: G = __v_3 * __v_56; let __v_59: G = __v_20 * __v_58; let __v_60: G = __v_57 + __v_59; let __v_61: G = __v_2 * __v_56; let __v_62: G = __v_3 * __v_53; let __v_63: G = __v_61 + __v_62; let __v_64: G = __v_35 + __v_60; let __v_65: G = __v_38 + __v_63; let __ret: [G; OUT_128] = [__v_64, __v_65]; record.function_queries[128].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_129: usize = 2; const IN_129: usize = 2; const OUT_129: usize = 1; -fn aiur_fn_129(inp: [G; IN_129], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_2 * __v_7); let __ret: [G; OUT_129] = [__v_8]; record.function_queries[129].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_129(inp: [G; IN_129], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __v_2 * __v_7; let __ret: [G; OUT_129] = [__v_8]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_130: usize = 8; const IN_130: usize = 8; const OUT_130: usize = 4; -fn aiur_fn_130(inp: [G; IN_130], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_130] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; match __v_18.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(256); let __v_23: G = (__v_22 * __v_10); let __v_24: G = G::from_u64(65536); let __v_25: G = (__v_24 * __v_11); let __v_26: G = G::from_u64(16777216); let __v_27: G = (__v_26 * __v_12); let __v_28: G = G::from_u64(4294967296); let __v_29: G = (__v_28 * __v_13); let __v_30: G = G::from_u64(1099511627776); let __v_31: G = (__v_30 * __v_14); let __v_32: G = G::from_u64(281474976710656); let __v_33: G = (__v_32 * __v_15); let __v_34: G = G::from_u64(72057594037927936); let __v_35: G = (__v_34 * __v_16); let __v_36: G = (__v_33 + __v_35); let __v_37: G = (__v_31 + __v_36); let __v_38: G = (__v_29 + __v_37); let __v_39: G = (__v_27 + __v_38); let __v_40: G = (__v_25 + __v_39); let __v_41: G = (__v_23 + __v_40); let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = (__v_19 - __v_42); let __v_45: G = (__v_20 - __v_43); let __v_46: G = (__v_6 * __v_44); let __v_47: G = G::from_u64(7); let __v_48: G = (__v_7 * __v_45); let __v_49: G = (__v_47 * __v_48); let __v_50: G = (__v_46 + __v_49); let __v_51: G = (__v_6 * __v_45); let __v_52: G = (__v_7 * __v_44); let __v_53: G = (__v_51 + __v_52); let __v_54: G = (__v_4 + __v_50); let __v_55: G = (__v_5 + __v_53); let __v_56: G = (__v_6 * __v_2); let __v_57: G = (__v_7 * __v_3); let __v_58: G = (__v_47 * __v_57); let __v_59: G = (__v_56 + __v_58); let __v_60: G = (__v_6 * __v_3); let __v_61: G = (__v_7 * __v_2); let __v_62: G = (__v_60 + __v_61); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __ret: [G; OUT_130] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[130].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_130(inp: [G; IN_130], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_130] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; match __v_18.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(256); let __v_23: G = __v_22 * __v_10; let __v_24: G = G::from_u64(65536); let __v_25: G = __v_24 * __v_11; let __v_26: G = G::from_u64(16777216); let __v_27: G = __v_26 * __v_12; let __v_28: G = G::from_u64(4294967296); let __v_29: G = __v_28 * __v_13; let __v_30: G = G::from_u64(1099511627776); let __v_31: G = __v_30 * __v_14; let __v_32: G = G::from_u64(281474976710656); let __v_33: G = __v_32 * __v_15; let __v_34: G = G::from_u64(72057594037927936); let __v_35: G = __v_34 * __v_16; let __v_36: G = __v_33 + __v_35; let __v_37: G = __v_31 + __v_36; let __v_38: G = __v_29 + __v_37; let __v_39: G = __v_27 + __v_38; let __v_40: G = __v_25 + __v_39; let __v_41: G = __v_23 + __v_40; let __v_42: G = __v_9 + __v_41; let __v_43: G = G::from_u64(0); let __v_44: G = __v_19 - __v_42; let __v_45: G = __v_20 - __v_43; let __v_46: G = __v_6 * __v_44; let __v_47: G = G::from_u64(7); let __v_48: G = __v_7 * __v_45; let __v_49: G = __v_47 * __v_48; let __v_50: G = __v_46 + __v_49; let __v_51: G = __v_6 * __v_45; let __v_52: G = __v_7 * __v_44; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_4 + __v_50; let __v_55: G = __v_5 + __v_53; let __v_56: G = __v_6 * __v_2; let __v_57: G = __v_7 * __v_3; let __v_58: G = __v_47 * __v_57; let __v_59: G = __v_56 + __v_58; let __v_60: G = __v_6 * __v_3; let __v_61: G = __v_7 * __v_2; let __v_62: G = __v_60 + __v_61; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __ret: [G; OUT_130] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_131: usize = 2; const IN_131: usize = 2; const OUT_131: usize = 1; -fn aiur_fn_131(inp: [G; IN_131], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_131] = [__v_1]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_6: G = G::from_u8(__gb[0]); let __v_7: G = G::from_u8(__gb[1]); let __v_8: G = G::from_u8(__gb[2]); let __v_9: G = G::from_u8(__gb[3]); let __v_10: G = G::from_u8(__gb[4]); let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_14: G = G::from_u64(256); let __v_15: G = (__v_14 * __v_7); let __v_16: G = G::from_u64(65536); let __v_17: G = (__v_16 * __v_8); let __v_18: G = G::from_u64(16777216); let __v_19: G = (__v_18 * __v_9); let __v_20: G = G::from_u64(4294967296); let __v_21: G = (__v_20 * __v_10); let __v_22: G = G::from_u64(1099511627776); let __v_23: G = (__v_22 * __v_11); let __v_24: G = G::from_u64(281474976710656); let __v_25: G = (__v_24 * __v_12); let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = (__v_26 * __v_13); let __v_28: G = (__v_25 + __v_27); let __v_29: G = (__v_23 + __v_28); let __v_30: G = (__v_21 + __v_29); let __v_31: G = (__v_19 + __v_30); let __v_32: G = (__v_17 + __v_31); let __v_33: G = (__v_15 + __v_32); let __v_34: G = (__v_6 + __v_33); if (__v_34 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_35: G = G::from_u64(1020); let __v_36: G = (__v_13 - __v_35); let __v_37: G = (__v_12 + __v_36); let __v_38: G = (__v_11 + __v_37); let __v_39: G = (__v_10 + __v_38); let __v_40: G = G::from_bool((__v_39 == G::ZERO)); let __v_41: G = (__v_8 + __v_9); let __v_42: G = (__v_7 + __v_41); let __v_43: G = (__v_6 + __v_42); let __v_44: G = G::from_bool((__v_43 == G::ZERO)); let __v_45: G = G::from_u64(1); let __v_46: G = (__v_45 - __v_44); let __v_47: G = (__v_40 * __v_46); let __v_48: G = (__v_45 - __v_47); if (__v_48 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes(); let __v_49: G = G::from_u8(__gb[0]); let __v_50: G = G::from_u8(__gb[1]); let __v_51: G = G::from_u8(__gb[2]); let __v_52: G = G::from_u8(__gb[3]); let __v_53: G = G::from_u8(__gb[4]); let __v_54: G = G::from_u8(__gb[5]); let __v_55: G = G::from_u8(__gb[6]); let __v_56: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_57: G = (__v_14 * __v_50); let __v_58: G = (__v_16 * __v_51); let __v_59: G = (__v_18 * __v_52); let __v_60: G = (__v_20 * __v_53); let __v_61: G = (__v_22 * __v_54); let __v_62: G = (__v_24 * __v_55); let __v_63: G = (__v_26 * __v_56); let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_61 + __v_64); let __v_66: G = (__v_60 + __v_65); let __v_67: G = (__v_59 + __v_66); let __v_68: G = (__v_58 + __v_67); let __v_69: G = (__v_57 + __v_68); let __v_70: G = (__v_49 + __v_69); if (__v_70 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } let __v_71: G = (__v_56 - __v_35); let __v_72: G = (__v_55 + __v_71); let __v_73: G = (__v_54 + __v_72); let __v_74: G = (__v_53 + __v_73); let __v_75: G = G::from_bool((__v_74 == G::ZERO)); let __v_76: G = (__v_51 + __v_52); let __v_77: G = (__v_50 + __v_76); let __v_78: G = (__v_49 + __v_77); let __v_79: G = G::from_bool((__v_78 == G::ZERO)); let __v_80: G = (__v_45 - __v_79); let __v_81: G = (__v_75 * __v_80); let __v_82: G = (__v_45 - __v_81); if (__v_82 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_85]; record.function_queries[131].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_131(inp: [G; IN_131], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_131] = [__v_1]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_6: G = G::from_u8(__gb[0]); let __v_7: G = G::from_u8(__gb[1]); let __v_8: G = G::from_u8(__gb[2]); let __v_9: G = G::from_u8(__gb[3]); let __v_10: G = G::from_u8(__gb[4]); let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_14: G = G::from_u64(256); let __v_15: G = __v_14 * __v_7; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_8; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_9; let __v_20: G = G::from_u64(4294967296); let __v_21: G = __v_20 * __v_10; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_11; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_12; let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = __v_26 * __v_13; let __v_28: G = __v_25 + __v_27; let __v_29: G = __v_23 + __v_28; let __v_30: G = __v_21 + __v_29; let __v_31: G = __v_19 + __v_30; let __v_32: G = __v_17 + __v_31; let __v_33: G = __v_15 + __v_32; let __v_34: G = __v_6 + __v_33; if (__v_34 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_35: G = G::from_u64(1020); let __v_36: G = __v_13 - __v_35; let __v_37: G = __v_12 + __v_36; let __v_38: G = __v_11 + __v_37; let __v_39: G = __v_10 + __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = __v_8 + __v_9; let __v_42: G = __v_7 + __v_41; let __v_43: G = __v_6 + __v_42; let __v_44: G = G::from_bool(__v_43 == G::ZERO); let __v_45: G = G::from_u64(1); let __v_46: G = __v_45 - __v_44; let __v_47: G = __v_40 * __v_46; let __v_48: G = __v_45 - __v_47; if (__v_48 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes(); let __v_49: G = G::from_u8(__gb[0]); let __v_50: G = G::from_u8(__gb[1]); let __v_51: G = G::from_u8(__gb[2]); let __v_52: G = G::from_u8(__gb[3]); let __v_53: G = G::from_u8(__gb[4]); let __v_54: G = G::from_u8(__gb[5]); let __v_55: G = G::from_u8(__gb[6]); let __v_56: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_57: G = __v_14 * __v_50; let __v_58: G = __v_16 * __v_51; let __v_59: G = __v_18 * __v_52; let __v_60: G = __v_20 * __v_53; let __v_61: G = __v_22 * __v_54; let __v_62: G = __v_24 * __v_55; let __v_63: G = __v_26 * __v_56; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_61 + __v_64; let __v_66: G = __v_60 + __v_65; let __v_67: G = __v_59 + __v_66; let __v_68: G = __v_58 + __v_67; let __v_69: G = __v_57 + __v_68; let __v_70: G = __v_49 + __v_69; if (__v_70 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } let __v_71: G = __v_56 - __v_35; let __v_72: G = __v_55 + __v_71; let __v_73: G = __v_54 + __v_72; let __v_74: G = __v_53 + __v_73; let __v_75: G = G::from_bool(__v_74 == G::ZERO); let __v_76: G = __v_51 + __v_52; let __v_77: G = __v_50 + __v_76; let __v_78: G = __v_49 + __v_77; let __v_79: G = G::from_bool(__v_78 == G::ZERO); let __v_80: G = __v_45 - __v_79; let __v_81: G = __v_75 * __v_80; let __v_82: G = __v_45 - __v_81; if (__v_82 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_85]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_132: usize = 2; const IN_132: usize = 2; const OUT_132: usize = 1; -fn aiur_fn_132(inp: [G; IN_132], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_132] = [__v_1]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, (&__args[..]))?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { (*(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132])) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_6]; record.function_queries[132].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_132(inp: [G; IN_132], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_132] = [__v_1]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, &__args[..])?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_6]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_133: usize = 2; const IN_133: usize = 2; const OUT_133: usize = 1; -fn aiur_fn_133(inp: [G; IN_133], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_133] = [__v_1]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, (&__args[..]))?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { (*(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132])) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_6]; record.function_queries[133].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_133(inp: [G; IN_133], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_133] = [__v_1]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(132, &__args[..])?) { [G::ZERO; OUT_132] } else { let (__hash, __hit) = record.function_queries[132].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[132].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => { aiur_fn_132::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_6]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_134: usize = 3; const IN_134: usize = 3; const OUT_134: usize = 1; -fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_134] = [__v_2]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_3]; record.function_queries[134].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_134(inp: [G; IN_134], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_134] = [__v_2]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_3]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_135: usize = 2; const IN_135: usize = 2; const OUT_135: usize = 1; -fn aiur_fn_135(inp: [G; IN_135], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_135] = [__v_0]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_8]; record.function_queries[135].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_135(inp: [G; IN_135], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_135] = [__v_0]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_8]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_136: usize = 10; const IN_136: usize = 10; const OUT_136: usize = 2; -fn aiur_fn_136(inp: [G; IN_136], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_136] = [__v_0, __v_11]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, (&__args[..]))?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { (*(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118])) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_136] = [__v_14, __v_15]; record.function_queries[136].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_136(inp: [G; IN_136], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_136] = [__v_0, __v_11]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(118, &__args[..])?) { [G::ZERO; OUT_118] } else { let (__hash, __hit) = record.function_queries[118].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[118].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => { aiur_fn_118::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_136] = [__v_14, __v_15]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_137: usize = 4; const IN_137: usize = 4; const OUT_137: usize = 2; -fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_8, __v_0]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; let __v_32: G = __r_arr[12]; let __v_33: G = __r_arr[13]; let __v_34: G = __r_arr[14]; let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, (&__args[..]))?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { (*(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137])) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(256); let __v_41: G = (__v_40 * __v_21); let __v_42: G = G::from_u64(65536); let __v_43: G = (__v_42 * __v_22); let __v_44: G = G::from_u64(16777216); let __v_45: G = (__v_44 * __v_23); let __v_46: G = G::from_u64(4294967296); let __v_47: G = (__v_46 * __v_24); let __v_48: G = G::from_u64(1099511627776); let __v_49: G = (__v_48 * __v_25); let __v_50: G = G::from_u64(281474976710656); let __v_51: G = (__v_50 * __v_26); let __v_52: G = G::from_u64(72057594037927936); let __v_53: G = (__v_52 * __v_27); let __v_54: G = (__v_51 + __v_53); let __v_55: G = (__v_49 + __v_54); let __v_56: G = (__v_47 + __v_55); let __v_57: G = (__v_45 + __v_56); let __v_58: G = (__v_43 + __v_57); let __v_59: G = (__v_41 + __v_58); let __v_60: G = (__v_20 + __v_59); let __v_61: G = G::from_u64(0); let __v_62: G = (__v_40 * __v_29); let __v_63: G = (__v_42 * __v_30); let __v_64: G = (__v_44 * __v_31); let __v_65: G = (__v_46 * __v_32); let __v_66: G = (__v_48 * __v_33); let __v_67: G = (__v_50 * __v_34); let __v_68: G = (__v_52 * __v_35); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_66 + __v_69); let __v_71: G = (__v_65 + __v_70); let __v_72: G = (__v_64 + __v_71); let __v_73: G = (__v_63 + __v_72); let __v_74: G = (__v_62 + __v_73); let __v_75: G = (__v_28 + __v_74); let __v_76: G = { let __values: [G; 4] = [__v_61, __v_60, __v_75, __v_38]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_76, __v_39]; record.function_queries[137].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } +fn aiur_fn_137(inp: [G; IN_137], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_8, __v_0]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; let __v_24: G = __r_arr[4]; let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; let __v_32: G = __r_arr[12]; let __v_33: G = __r_arr[13]; let __v_34: G = __r_arr[14]; let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, &__args[..])?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(256); let __v_41: G = __v_40 * __v_21; let __v_42: G = G::from_u64(65536); let __v_43: G = __v_42 * __v_22; let __v_44: G = G::from_u64(16777216); let __v_45: G = __v_44 * __v_23; let __v_46: G = G::from_u64(4294967296); let __v_47: G = __v_46 * __v_24; let __v_48: G = G::from_u64(1099511627776); let __v_49: G = __v_48 * __v_25; let __v_50: G = G::from_u64(281474976710656); let __v_51: G = __v_50 * __v_26; let __v_52: G = G::from_u64(72057594037927936); let __v_53: G = __v_52 * __v_27; let __v_54: G = __v_51 + __v_53; let __v_55: G = __v_49 + __v_54; let __v_56: G = __v_47 + __v_55; let __v_57: G = __v_45 + __v_56; let __v_58: G = __v_43 + __v_57; let __v_59: G = __v_41 + __v_58; let __v_60: G = __v_20 + __v_59; let __v_61: G = G::from_u64(0); let __v_62: G = __v_40 * __v_29; let __v_63: G = __v_42 * __v_30; let __v_64: G = __v_44 * __v_31; let __v_65: G = __v_46 * __v_32; let __v_66: G = __v_48 * __v_33; let __v_67: G = __v_50 * __v_34; let __v_68: G = __v_52 * __v_35; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_66 + __v_69; let __v_71: G = __v_65 + __v_70; let __v_72: G = __v_64 + __v_71; let __v_73: G = __v_63 + __v_72; let __v_74: G = __v_62 + __v_73; let __v_75: G = __v_28 + __v_74; let __v_76: G = { let __values: [G; 4] = [__v_61, __v_60, __v_75, __v_38]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_137] = [__v_76, __v_39]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } const INPUT_SIZE_138: usize = 5; const IN_138: usize = 5; const OUT_138: usize = 1; -fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_5]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); let __v_8: G = G::from_bool((__v_7 == G::ZERO)); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_138] = [__v_9]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 - __v_9); let __v_11: G = (__v_3 + __v_9); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_10, __v_11, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_12]; record.function_queries[138].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_138(inp: [G; IN_138], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_5]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_1 - __v_4; let __v_7: G = __v_5 + __v_6; let __v_8: G = G::from_bool(__v_7 == G::ZERO); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_138] = [__v_9]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __v_11: G = __v_3 + __v_9; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_10, __v_11, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_12]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_139: usize = 4; const IN_139: usize = 4; const OUT_139: usize = 1; -fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 7] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_5]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, (&__args[..]))?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { (*(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138])) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_8]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_6, __v_6, __v_6, __v_9]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_10]; record.function_queries[139].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_139(inp: [G; IN_139], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 7] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_5]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(138, &__args[..])?) { [G::ZERO; OUT_138] } else { let (__hash, __hit) = record.function_queries[138].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[138].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => { aiur_fn_138::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_3 - __v_6; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_8]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = __v_3 - __v_7; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_6, __v_6, __v_6, __v_9]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_139] = [__v_10]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_140: usize = 8; const IN_140: usize = 8; const OUT_140: usize = 1; -fn aiur_fn_140(inp: [G; IN_140], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; match __v_8.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 7] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_16]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { _ => { let __v_15: G = (__v_9 - __v_1); let __v_16: G = G::from_bool((__v_15 == G::ZERO)); match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, (&__args[..]))?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { (*(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130])) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = (__v_4 * __v_18); let __v_23: G = G::from_u64(7); let __v_24: G = (__v_5 * __v_19); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_22 + __v_25); let __v_27: G = (__v_4 * __v_19); let __v_28: G = (__v_5 * __v_18); let __v_29: G = (__v_27 + __v_28); let __v_30: G = (__v_12 + __v_26); let __v_31: G = (__v_13 + __v_29); let __v_32: G = { let __values: [G; 7] = [__v_17, __v_9, __v_20, __v_21, __v_30, __v_31, __v_14]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_32]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 7)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_19]; record.function_queries[140].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } +fn aiur_fn_140(inp: [G; IN_140], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; match __v_8.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 7] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_16]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { _ => { let __v_15: G = __v_9 - __v_1; let __v_16: G = G::from_bool(__v_15 == G::ZERO); match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(130, &__args[..])?) { [G::ZERO; OUT_130] } else { let (__hash, __hit) = record.function_queries[130].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[130].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => { aiur_fn_130::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = __v_4 * __v_18; let __v_23: G = G::from_u64(7); let __v_24: G = __v_5 * __v_19; let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 + __v_25; let __v_27: G = __v_4 * __v_19; let __v_28: G = __v_5 * __v_18; let __v_29: G = __v_27 + __v_28; let __v_30: G = __v_12 + __v_26; let __v_31: G = __v_13 + __v_29; let __v_32: G = { let __values: [G; 7] = [__v_17, __v_9, __v_20, __v_21, __v_30, __v_31, __v_14]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_32]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 7)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_140] = [__v_19]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } const INPUT_SIZE_141: usize = 2; const IN_141: usize = 2; const OUT_141: usize = 1; -fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_9: G = (__v_3 - __v_1); let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = (__v_6 - __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = (__v_7 - __v_11); let __v_15: G = G::from_bool((__v_14 == G::ZERO)); let __v_16: G = (__v_13 * __v_15); let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_141] = [__v_17]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_11]; record.function_queries[141].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_141(inp: [G; IN_141], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_9: G = __v_3 - __v_1; let __v_10: G = G::from_bool(__v_9 == G::ZERO); match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = __v_6 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_7 - __v_11; let __v_15: G = G::from_bool(__v_14 == G::ZERO); let __v_16: G = __v_13 * __v_15; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_141] = [__v_17]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_8, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, &__args[..])?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_11]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_142: usize = 2; const IN_142: usize = 2; const OUT_142: usize = 1; -fn aiur_fn_142(inp: [G; IN_142], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_142] = [__v_2]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_142] = [__v_2]; record.function_queries[142].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_142(inp: [G; IN_142], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_142] = [__v_2]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_142] = [__v_2]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_143: usize = 10; const IN_143: usize = 10; const OUT_143: usize = 1; -fn aiur_fn_143(inp: [G; IN_143], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_10 - __v_11); let __v_13: G = G::from_bool((__v_12 == G::ZERO)); let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_3 - __v_1); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(7); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, (&__args[..]))?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { (*(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127])) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_17 * __v_21); let __v_23: G = G::from_u64(0); let __v_24: G = (__v_4 - __v_22); let __v_25: G = (__v_5 - __v_23); let __v_26: G = (__v_24 * __v_24); let __v_27: G = (__v_25 * __v_25); let __v_28: G = (__v_17 * __v_27); let __v_29: G = (__v_26 - __v_28); let __v_30: G = aiur::execute::g_inverse_value(__v_29); let __v_31: G = (__v_29 * __v_30); let __v_32: G = (__v_31 - __v_14); let __v_33: G = (__v_29 * __v_32); if (__v_33 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_34: G = (__v_30 * __v_32); if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_35: G = (__v_24 * __v_30); let __v_36: G = (__v_23 - __v_25); let __v_37: G = (__v_36 * __v_30); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_6, __v_7, __v_35, __v_37, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, (&__args[..]))?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { (*(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140])) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_143] = [__v_38]; record.function_queries[143].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_143(inp: [G; IN_143], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __v_10 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_15: G = __v_3 - __v_1; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(7); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(127, &__args[..])?) { [G::ZERO; OUT_127] } else { let (__hash, __hit) = record.function_queries[127].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[127].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => { aiur_fn_127::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __v_17 * __v_21; let __v_23: G = G::from_u64(0); let __v_24: G = __v_4 - __v_22; let __v_25: G = __v_5 - __v_23; let __v_26: G = __v_24 * __v_24; let __v_27: G = __v_25 * __v_25; let __v_28: G = __v_17 * __v_27; let __v_29: G = __v_26 - __v_28; let __v_30: G = aiur::execute::g_inverse_value(__v_29); let __v_31: G = __v_29 * __v_30; let __v_32: G = __v_31 - __v_14; let __v_33: G = __v_29 * __v_32; if (__v_33 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_34: G = __v_30 * __v_32; if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __v_35: G = __v_24 * __v_30; let __v_36: G = __v_23 - __v_25; let __v_37: G = __v_36 * __v_30; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_6, __v_7, __v_35, __v_37, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(140, &__args[..])?) { [G::ZERO; OUT_140] } else { let (__hash, __hit) = record.function_queries[140].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[140].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => { aiur_fn_140::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_143] = [__v_38]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_144: usize = 11; const IN_144: usize = 11; const OUT_144: usize = 1; -fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_5 * __v_15); let __v_17: G = G::from_u64(7); let __v_18: G = (__v_6 * __v_11); let __v_19: G = (__v_17 * __v_18); let __v_20: G = (__v_16 + __v_19); let __v_21: G = (__v_5 * __v_11); let __v_22: G = (__v_6 * __v_15); let __v_23: G = (__v_21 + __v_22); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_24, __v_3, __v_1, __v_2, __v_20, __v_23, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_25]; record.function_queries[144].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_144(inp: [G; IN_144], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __v_5 * __v_15; let __v_17: G = G::from_u64(7); let __v_18: G = __v_6 * __v_11; let __v_19: G = __v_17 * __v_18; let __v_20: G = __v_16 + __v_19; let __v_21: G = __v_5 * __v_11; let __v_22: G = __v_6 * __v_15; let __v_23: G = __v_21 + __v_22; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_24, __v_3, __v_1, __v_2, __v_20, __v_23, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_25]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_145: usize = 13; const IN_145: usize = 13; const OUT_145: usize = 1; -fn aiur_fn_145(inp: [G; IN_145], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_145] = [__v_0]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_4 + __v_18); let __v_20: G = (__v_5 - __v_18); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_21]; record.function_queries[145].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_145(inp: [G; IN_145], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_145] = [__v_0]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, &__args[..])?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = __v_4 + __v_18; let __v_20: G = __v_5 - __v_18; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_21]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_146: usize = 13; const IN_146: usize = 13; const OUT_146: usize = 1; -fn aiur_fn_146(inp: [G; IN_146], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_146] = [__v_0]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, (&__args[..]))?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { (*(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143])) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_4 + __v_20); let __v_22: G = (__v_5 - __v_20); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_23]; record.function_queries[146].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_146(inp: [G; IN_146], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_146] = [__v_0]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(143, &__args[..])?) { [G::ZERO; OUT_143] } else { let (__hash, __hit) = record.function_queries[143].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[143].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => { aiur_fn_143::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = __v_4 + __v_20; let __v_22: G = __v_5 - __v_20; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_23]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_147: usize = 15; const IN_147: usize = 15; const OUT_147: usize = 1; -fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_147] = [__v_0]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); let __v_19: G = (__v_5 - __v_17); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_19, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_20]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, (&__args[..]))?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { (*(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144])) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); let __v_24: G = (__v_5 - __v_22); let __v_25: G = (__v_6 + __v_22); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_24, __v_25, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_26]; record.function_queries[147].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_147(inp: [G; IN_147], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_147] = [__v_0]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = __v_4 + __v_17; let __v_19: G = __v_5 - __v_17; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_19, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_20]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_17 + __v_3; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(144, &__args[..])?) { [G::ZERO; OUT_144] } else { let (__hash, __hit) = record.function_queries[144].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[144].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => { aiur_fn_144::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = __v_4 + __v_22; let __v_24: G = __v_5 - __v_22; let __v_25: G = __v_6 + __v_22; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_24, __v_25, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_26]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_148: usize = 15; const IN_148: usize = 15; const OUT_148: usize = 1; -fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = G::from_bool((__v_19 == G::ZERO)); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_6, __v_10, __v_5, __v_7, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_8, __v_9, __v_10, __v_22, __v_7, __v_22, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, (&__args[..]))?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { (*(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147])) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_25]; record.function_queries[148].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_148(inp: [G; IN_148], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_148] = [__v_0]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __v_17 - __v_18; let __v_20: G = G::from_bool(__v_19 == G::ZERO); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_6, __v_10, __v_5, __v_7, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_8, __v_9, __v_10, __v_22, __v_7, __v_22, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(147, &__args[..])?) { [G::ZERO; OUT_147] } else { let (__hash, __hit) = record.function_queries[147].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[147].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => { aiur_fn_147::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_25]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_149: usize = 4; const IN_149: usize = 4; const OUT_149: usize = 1; -fn aiur_fn_149(inp: [G; IN_149], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_5]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_5 + __v_1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = (__v_3 + __v_7); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_11]; record.function_queries[149].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_149(inp: [G; IN_149], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_5]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_5 + __v_1; let __v_7: G = G::from_u64(1); let __v_8: G = __v_2 - __v_7; let __v_9: G = __v_3 + __v_7; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_149] = [__v_11]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_150: usize = 1; const IN_150: usize = 1; const OUT_150: usize = 1; -fn aiur_fn_150(inp: [G; IN_150], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_150] = [__v_2]; record.function_queries[150].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_150(inp: [G; IN_150], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_150] = [__v_4]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_150] = [__v_2]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_151: usize = 5; const IN_151: usize = 5; const OUT_151: usize = 1; -fn aiur_fn_151(inp: [G; IN_151], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_6]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); let __v_9: G = (__v_4 + __v_7); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_10]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_8 + __v_1); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 - __v_10); let __v_12: G = (__v_4 + __v_10); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_7, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_14]; record.function_queries[151].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_151(inp: [G; IN_151], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_6]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_3 - __v_7; let __v_9: G = __v_4 + __v_7; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_10]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __v_8 + __v_1; let __v_10: G = G::from_u64(1); let __v_11: G = __v_3 - __v_10; let __v_12: G = __v_4 + __v_10; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_7, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_151] = [__v_14]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_152: usize = 5; const IN_152: usize = 5; const OUT_152: usize = 4; -fn aiur_fn_152(inp: [G; IN_152], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_152] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_152] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[152].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_152(inp: [G; IN_152], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_152] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_152] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_153: usize = 4; const IN_153: usize = 4; const OUT_153: usize = 1; -fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); let __v_6: G = G::from_u8(__gb[2]); let __v_7: G = G::from_u8(__gb[3]); let __v_8: G = G::from_u8(__gb[4]); let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_12: G = G::from_u64(256); let __v_13: G = (__v_12 * __v_5); let __v_14: G = G::from_u64(65536); let __v_15: G = (__v_14 * __v_6); let __v_16: G = G::from_u64(16777216); let __v_17: G = (__v_16 * __v_7); let __v_18: G = G::from_u64(4294967296); let __v_19: G = (__v_18 * __v_8); let __v_20: G = G::from_u64(1099511627776); let __v_21: G = (__v_20 * __v_9); let __v_22: G = G::from_u64(281474976710656); let __v_23: G = (__v_22 * __v_10); let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = (__v_24 * __v_11); let __v_26: G = (__v_23 + __v_25); let __v_27: G = (__v_21 + __v_26); let __v_28: G = (__v_19 + __v_27); let __v_29: G = (__v_17 + __v_28); let __v_30: G = (__v_15 + __v_29); let __v_31: G = (__v_13 + __v_30); let __v_32: G = (__v_4 + __v_31); if (__v_32 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_33: G = G::from_u64(1020); let __v_34: G = (__v_11 - __v_33); let __v_35: G = (__v_10 + __v_34); let __v_36: G = (__v_9 + __v_35); let __v_37: G = (__v_8 + __v_36); let __v_38: G = G::from_bool((__v_37 == G::ZERO)); let __v_39: G = (__v_6 + __v_7); let __v_40: G = (__v_5 + __v_39); let __v_41: G = (__v_4 + __v_40); let __v_42: G = G::from_bool((__v_41 == G::ZERO)); let __v_43: G = G::from_u64(1); let __v_44: G = (__v_43 - __v_42); let __v_45: G = (__v_38 * __v_44); let __v_46: G = (__v_43 - __v_45); if (__v_46 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_47: G = G::from_u8(__gb[0]); let __v_48: G = G::from_u8(__gb[1]); let __v_49: G = G::from_u8(__gb[2]); let __v_50: G = G::from_u8(__gb[3]); let __v_51: G = G::from_u8(__gb[4]); let __v_52: G = G::from_u8(__gb[5]); let __v_53: G = G::from_u8(__gb[6]); let __v_54: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_47; let __vj = __v_48; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_55: G = (__v_12 * __v_48); let __v_56: G = (__v_14 * __v_49); let __v_57: G = (__v_16 * __v_50); let __v_58: G = (__v_18 * __v_51); let __v_59: G = (__v_20 * __v_52); let __v_60: G = (__v_22 * __v_53); let __v_61: G = (__v_24 * __v_54); let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 + __v_62); let __v_64: G = (__v_58 + __v_63); let __v_65: G = (__v_57 + __v_64); let __v_66: G = (__v_56 + __v_65); let __v_67: G = (__v_55 + __v_66); let __v_68: G = (__v_47 + __v_67); if (__v_68 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_69: G = (__v_54 - __v_33); let __v_70: G = (__v_53 + __v_69); let __v_71: G = (__v_52 + __v_70); let __v_72: G = (__v_51 + __v_71); let __v_73: G = G::from_bool((__v_72 == G::ZERO)); let __v_74: G = (__v_49 + __v_50); let __v_75: G = (__v_48 + __v_74); let __v_76: G = (__v_47 + __v_75); let __v_77: G = G::from_bool((__v_76 == G::ZERO)); let __v_78: G = (__v_43 - __v_77); let __v_79: G = (__v_73 * __v_78); let __v_80: G = (__v_43 - __v_79); if (__v_80 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_81: G = G::from_u8(__gb[0]); let __v_82: G = G::from_u8(__gb[1]); let __v_83: G = G::from_u8(__gb[2]); let __v_84: G = G::from_u8(__gb[3]); let __v_85: G = G::from_u8(__gb[4]); let __v_86: G = G::from_u8(__gb[5]); let __v_87: G = G::from_u8(__gb[6]); let __v_88: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_81; let __vj = __v_82; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_83; let __vj = __v_84; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_89: G = (__v_12 * __v_82); let __v_90: G = (__v_14 * __v_83); let __v_91: G = (__v_16 * __v_84); let __v_92: G = (__v_18 * __v_85); let __v_93: G = (__v_20 * __v_86); let __v_94: G = (__v_22 * __v_87); let __v_95: G = (__v_24 * __v_88); let __v_96: G = (__v_94 + __v_95); let __v_97: G = (__v_93 + __v_96); let __v_98: G = (__v_92 + __v_97); let __v_99: G = (__v_91 + __v_98); let __v_100: G = (__v_90 + __v_99); let __v_101: G = (__v_89 + __v_100); let __v_102: G = (__v_81 + __v_101); if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_103: G = (__v_88 - __v_33); let __v_104: G = (__v_87 + __v_103); let __v_105: G = (__v_86 + __v_104); let __v_106: G = (__v_85 + __v_105); let __v_107: G = G::from_bool((__v_106 == G::ZERO)); let __v_108: G = (__v_83 + __v_84); let __v_109: G = (__v_82 + __v_108); let __v_110: G = (__v_81 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); let __v_112: G = (__v_43 - __v_111); let __v_113: G = (__v_107 * __v_112); let __v_114: G = (__v_43 - __v_113); if (__v_114 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_115: G = G::from_u8(__gb[0]); let __v_116: G = G::from_u8(__gb[1]); let __v_117: G = G::from_u8(__gb[2]); let __v_118: G = G::from_u8(__gb[3]); let __v_119: G = G::from_u8(__gb[4]); let __v_120: G = G::from_u8(__gb[5]); let __v_121: G = G::from_u8(__gb[6]); let __v_122: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_115; let __vj = __v_116; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_117; let __vj = __v_118; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_123: G = (__v_12 * __v_116); let __v_124: G = (__v_14 * __v_117); let __v_125: G = (__v_16 * __v_118); let __v_126: G = (__v_18 * __v_119); let __v_127: G = (__v_20 * __v_120); let __v_128: G = (__v_22 * __v_121); let __v_129: G = (__v_24 * __v_122); let __v_130: G = (__v_128 + __v_129); let __v_131: G = (__v_127 + __v_130); let __v_132: G = (__v_126 + __v_131); let __v_133: G = (__v_125 + __v_132); let __v_134: G = (__v_124 + __v_133); let __v_135: G = (__v_123 + __v_134); let __v_136: G = (__v_115 + __v_135); if (__v_136 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_137: G = (__v_122 - __v_33); let __v_138: G = (__v_121 + __v_137); let __v_139: G = (__v_120 + __v_138); let __v_140: G = (__v_119 + __v_139); let __v_141: G = G::from_bool((__v_140 == G::ZERO)); let __v_142: G = (__v_117 + __v_118); let __v_143: G = (__v_116 + __v_142); let __v_144: G = (__v_115 + __v_143); let __v_145: G = G::from_bool((__v_144 == G::ZERO)); let __v_146: G = (__v_43 - __v_145); let __v_147: G = (__v_141 * __v_146); let __v_148: G = (__v_43 - __v_147); if (__v_148 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __v_149: G = G::from_u64(0); let __v_150: G = { let __values: [G; 10] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_151: G = { let __values: [G; 10] = [__v_149, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_150]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_152: G = { let __values: [G; 10] = [__v_149, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_151]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_153: G = { let __values: [G; 10] = [__v_149, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_152]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_154: G = { let __values: [G; 10] = [__v_149, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_153]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_153] = [__v_154]; record.function_queries[153].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_153(inp: [G; IN_153], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); let __v_6: G = G::from_u8(__gb[2]); let __v_7: G = G::from_u8(__gb[3]); let __v_8: G = G::from_u8(__gb[4]); let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_12: G = G::from_u64(256); let __v_13: G = __v_12 * __v_5; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_6; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_7; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_8; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_9; let __v_22: G = G::from_u64(281474976710656); let __v_23: G = __v_22 * __v_10; let __v_24: G = G::from_u64(72057594037927936); let __v_25: G = __v_24 * __v_11; let __v_26: G = __v_23 + __v_25; let __v_27: G = __v_21 + __v_26; let __v_28: G = __v_19 + __v_27; let __v_29: G = __v_17 + __v_28; let __v_30: G = __v_15 + __v_29; let __v_31: G = __v_13 + __v_30; let __v_32: G = __v_4 + __v_31; if (__v_32 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_33: G = G::from_u64(1020); let __v_34: G = __v_11 - __v_33; let __v_35: G = __v_10 + __v_34; let __v_36: G = __v_9 + __v_35; let __v_37: G = __v_8 + __v_36; let __v_38: G = G::from_bool(__v_37 == G::ZERO); let __v_39: G = __v_6 + __v_7; let __v_40: G = __v_5 + __v_39; let __v_41: G = __v_4 + __v_40; let __v_42: G = G::from_bool(__v_41 == G::ZERO); let __v_43: G = G::from_u64(1); let __v_44: G = __v_43 - __v_42; let __v_45: G = __v_38 * __v_44; let __v_46: G = __v_43 - __v_45; if (__v_46 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_47: G = G::from_u8(__gb[0]); let __v_48: G = G::from_u8(__gb[1]); let __v_49: G = G::from_u8(__gb[2]); let __v_50: G = G::from_u8(__gb[3]); let __v_51: G = G::from_u8(__gb[4]); let __v_52: G = G::from_u8(__gb[5]); let __v_53: G = G::from_u8(__gb[6]); let __v_54: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_47; let __vj = __v_48; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_49; let __vj = __v_50; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_55: G = __v_12 * __v_48; let __v_56: G = __v_14 * __v_49; let __v_57: G = __v_16 * __v_50; let __v_58: G = __v_18 * __v_51; let __v_59: G = __v_20 * __v_52; let __v_60: G = __v_22 * __v_53; let __v_61: G = __v_24 * __v_54; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_59 + __v_62; let __v_64: G = __v_58 + __v_63; let __v_65: G = __v_57 + __v_64; let __v_66: G = __v_56 + __v_65; let __v_67: G = __v_55 + __v_66; let __v_68: G = __v_47 + __v_67; if (__v_68 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_69: G = __v_54 - __v_33; let __v_70: G = __v_53 + __v_69; let __v_71: G = __v_52 + __v_70; let __v_72: G = __v_51 + __v_71; let __v_73: G = G::from_bool(__v_72 == G::ZERO); let __v_74: G = __v_49 + __v_50; let __v_75: G = __v_48 + __v_74; let __v_76: G = __v_47 + __v_75; let __v_77: G = G::from_bool(__v_76 == G::ZERO); let __v_78: G = __v_43 - __v_77; let __v_79: G = __v_73 * __v_78; let __v_80: G = __v_43 - __v_79; if (__v_80 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_81: G = G::from_u8(__gb[0]); let __v_82: G = G::from_u8(__gb[1]); let __v_83: G = G::from_u8(__gb[2]); let __v_84: G = G::from_u8(__gb[3]); let __v_85: G = G::from_u8(__gb[4]); let __v_86: G = G::from_u8(__gb[5]); let __v_87: G = G::from_u8(__gb[6]); let __v_88: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_81; let __vj = __v_82; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_83; let __vj = __v_84; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_89: G = __v_12 * __v_82; let __v_90: G = __v_14 * __v_83; let __v_91: G = __v_16 * __v_84; let __v_92: G = __v_18 * __v_85; let __v_93: G = __v_20 * __v_86; let __v_94: G = __v_22 * __v_87; let __v_95: G = __v_24 * __v_88; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_93 + __v_96; let __v_98: G = __v_92 + __v_97; let __v_99: G = __v_91 + __v_98; let __v_100: G = __v_90 + __v_99; let __v_101: G = __v_89 + __v_100; let __v_102: G = __v_81 + __v_101; if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_103: G = __v_88 - __v_33; let __v_104: G = __v_87 + __v_103; let __v_105: G = __v_86 + __v_104; let __v_106: G = __v_85 + __v_105; let __v_107: G = G::from_bool(__v_106 == G::ZERO); let __v_108: G = __v_83 + __v_84; let __v_109: G = __v_82 + __v_108; let __v_110: G = __v_81 + __v_109; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_43 - __v_111; let __v_113: G = __v_107 * __v_112; let __v_114: G = __v_43 - __v_113; if (__v_114 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes(); let __v_115: G = G::from_u8(__gb[0]); let __v_116: G = G::from_u8(__gb[1]); let __v_117: G = G::from_u8(__gb[2]); let __v_118: G = G::from_u8(__gb[3]); let __v_119: G = G::from_u8(__gb[4]); let __v_120: G = G::from_u8(__gb[5]); let __v_121: G = G::from_u8(__gb[6]); let __v_122: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_115; let __vj = __v_116; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_117; let __vj = __v_118; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_123: G = __v_12 * __v_116; let __v_124: G = __v_14 * __v_117; let __v_125: G = __v_16 * __v_118; let __v_126: G = __v_18 * __v_119; let __v_127: G = __v_20 * __v_120; let __v_128: G = __v_22 * __v_121; let __v_129: G = __v_24 * __v_122; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_127 + __v_130; let __v_132: G = __v_126 + __v_131; let __v_133: G = __v_125 + __v_132; let __v_134: G = __v_124 + __v_133; let __v_135: G = __v_123 + __v_134; let __v_136: G = __v_115 + __v_135; if (__v_136 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } let __v_137: G = __v_122 - __v_33; let __v_138: G = __v_121 + __v_137; let __v_139: G = __v_120 + __v_138; let __v_140: G = __v_119 + __v_139; let __v_141: G = G::from_bool(__v_140 == G::ZERO); let __v_142: G = __v_117 + __v_118; let __v_143: G = __v_116 + __v_142; let __v_144: G = __v_115 + __v_143; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_43 - __v_145; let __v_147: G = __v_141 * __v_146; let __v_148: G = __v_43 - __v_147; if (__v_148 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None }); } let __v_149: G = G::from_u64(0); let __v_150: G = { let __values: [G; 10] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_151: G = { let __values: [G; 10] = [__v_149, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_150]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_152: G = { let __values: [G; 10] = [__v_149, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_151]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_153: G = { let __values: [G; 10] = [__v_149, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_152]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_154: G = { let __values: [G; 10] = [__v_149, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_153]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_153] = [__v_154]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_154: usize = 6; const IN_154: usize = 6; const OUT_154: usize = 3; -fn aiur_fn_154(inp: [G; IN_154], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_13: G = (__v_7 - __v_2); let __v_14: G = G::from_bool((__v_13 == G::ZERO)); match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); let __v_19: G = G::from_u64(7); let __v_20: G = (__v_17 * __v_11); let __v_21: G = (__v_19 * __v_20); let __v_22: G = (__v_18 + __v_21); let __v_23: G = (__v_16 * __v_11); let __v_24: G = (__v_17 * __v_10); let __v_25: G = (__v_23 + __v_24); let __v_26: G = (__v_0 + __v_22); let __v_27: G = (__v_1 + __v_25); let __ret: [G; OUT_154] = [__v_26, __v_27, __v_12]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +fn aiur_fn_154(inp: [G; IN_154], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_13: G = __v_7 - __v_2; let __v_14: G = G::from_bool(__v_13 == G::ZERO); match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __v_16 * __v_10; let __v_19: G = G::from_u64(7); let __v_20: G = __v_17 * __v_11; let __v_21: G = __v_19 * __v_20; let __v_22: G = __v_18 + __v_21; let __v_23: G = __v_16 * __v_11; let __v_24: G = __v_17 * __v_10; let __v_25: G = __v_23 + __v_24; let __v_26: G = __v_0 + __v_22; let __v_27: G = __v_1 + __v_25; let __ret: [G; OUT_154] = [__v_26, __v_27, __v_12]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_154] = [__v_0, __v_1, __v_5]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_155: usize = 9; const IN_155: usize = 9; const OUT_155: usize = 3; -fn aiur_fn_155(inp: [G; IN_155], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { let __v_13: G = (__v_6 - __v_8); let __v_14: G = G::from_bool((__v_13 == G::ZERO)); let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, (&__args[..]))?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { (*(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245])) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __v_18: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_0, __v_1, __v_18]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_6 - __v_25); let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_23.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_0, __v_1, __v_28, __v_29]; }, _ => { break '__mc_0 [__v_28, __v_29, __v_0, __v_1]; }, } }; let __v_30: G = __mc_out___mc_0[0]; let __v_31: G = __mc_out___mc_0[1]; let __v_32: G = __mc_out___mc_0[2]; let __v_33: G = __mc_out___mc_0[3]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, (&__args[..]))?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { (*(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128])) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, (&__args[..]))?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { (*(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154])) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_36, __v_37, __v_16, __v_19, __v_12, __v_24, __v_26, __v_38, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, (&__args[..]))?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { (*(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155])) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); let __v_42: G = G::from_u8(__gb[0]); let __v_43: G = G::from_u8(__gb[1]); let __v_44: G = G::from_u8(__gb[2]); let __v_45: G = G::from_u8(__gb[3]); let __v_46: G = G::from_u8(__gb[4]); let __v_47: G = G::from_u8(__gb[5]); let __v_48: G = G::from_u8(__gb[6]); let __v_49: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_48; let __vj = __v_49; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_50: G = G::from_u64(256); let __v_51: G = (__v_50 * __v_43); let __v_52: G = G::from_u64(65536); let __v_53: G = (__v_52 * __v_44); let __v_54: G = G::from_u64(16777216); let __v_55: G = (__v_54 * __v_45); let __v_56: G = G::from_u64(4294967296); let __v_57: G = (__v_56 * __v_46); let __v_58: G = G::from_u64(1099511627776); let __v_59: G = (__v_58 * __v_47); let __v_60: G = G::from_u64(281474976710656); let __v_61: G = (__v_60 * __v_48); let __v_62: G = G::from_u64(72057594037927936); let __v_63: G = (__v_62 * __v_49); let __v_64: G = (__v_61 + __v_63); let __v_65: G = (__v_59 + __v_64); let __v_66: G = (__v_57 + __v_65); let __v_67: G = (__v_55 + __v_66); let __v_68: G = (__v_53 + __v_67); let __v_69: G = (__v_51 + __v_68); let __v_70: G = (__v_42 + __v_69); if (__v_70 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __v_71: G = G::from_u64(1020); let __v_72: G = (__v_49 - __v_71); let __v_73: G = (__v_48 + __v_72); let __v_74: G = (__v_47 + __v_73); let __v_75: G = (__v_46 + __v_74); let __v_76: G = G::from_bool((__v_75 == G::ZERO)); let __v_77: G = (__v_44 + __v_45); let __v_78: G = (__v_43 + __v_77); let __v_79: G = (__v_42 + __v_78); let __v_80: G = G::from_bool((__v_79 == G::ZERO)); let __v_81: G = G::from_u64(1); let __v_82: G = (__v_81 - __v_80); let __v_83: G = (__v_76 * __v_82); let __v_84: G = (__v_81 - __v_83); if (__v_84 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); let __v_85: G = G::from_u8(__gb[0]); let __v_86: G = G::from_u8(__gb[1]); let __v_87: G = G::from_u8(__gb[2]); let __v_88: G = G::from_u8(__gb[3]); let __v_89: G = G::from_u8(__gb[4]); let __v_90: G = G::from_u8(__gb[5]); let __v_91: G = G::from_u8(__gb[6]); let __v_92: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_93: G = (__v_50 * __v_86); let __v_94: G = (__v_52 * __v_87); let __v_95: G = (__v_54 * __v_88); let __v_96: G = (__v_56 * __v_89); let __v_97: G = (__v_58 * __v_90); let __v_98: G = (__v_60 * __v_91); let __v_99: G = (__v_62 * __v_92); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_97 + __v_100); let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_95 + __v_102); let __v_104: G = (__v_94 + __v_103); let __v_105: G = (__v_93 + __v_104); let __v_106: G = (__v_85 + __v_105); if (__v_106 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_106.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_107: G = (__v_92 - __v_71); let __v_108: G = (__v_91 + __v_107); let __v_109: G = (__v_90 + __v_108); let __v_110: G = (__v_89 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); let __v_112: G = (__v_87 + __v_88); let __v_113: G = (__v_86 + __v_112); let __v_114: G = (__v_85 + __v_113); let __v_115: G = G::from_bool((__v_114 == G::ZERO)); let __v_116: G = (__v_81 - __v_115); let __v_117: G = (__v_111 * __v_116); let __v_118: G = (__v_81 - __v_117); if (__v_118 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_119: G = G::from_u8(__gb[0]); let __v_120: G = G::from_u8(__gb[1]); let __v_121: G = G::from_u8(__gb[2]); let __v_122: G = G::from_u8(__gb[3]); let __v_123: G = G::from_u8(__gb[4]); let __v_124: G = G::from_u8(__gb[5]); let __v_125: G = G::from_u8(__gb[6]); let __v_126: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_123; let __vj = __v_124; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_125; let __vj = __v_126; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_127: G = (__v_50 * __v_120); let __v_128: G = (__v_52 * __v_121); let __v_129: G = (__v_54 * __v_122); let __v_130: G = (__v_56 * __v_123); let __v_131: G = (__v_58 * __v_124); let __v_132: G = (__v_60 * __v_125); let __v_133: G = (__v_62 * __v_126); let __v_134: G = (__v_132 + __v_133); let __v_135: G = (__v_131 + __v_134); let __v_136: G = (__v_130 + __v_135); let __v_137: G = (__v_129 + __v_136); let __v_138: G = (__v_128 + __v_137); let __v_139: G = (__v_127 + __v_138); let __v_140: G = (__v_119 + __v_139); if (__v_140 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_141: G = (__v_126 - __v_71); let __v_142: G = (__v_125 + __v_141); let __v_143: G = (__v_124 + __v_142); let __v_144: G = (__v_123 + __v_143); let __v_145: G = G::from_bool((__v_144 == G::ZERO)); let __v_146: G = (__v_121 + __v_122); let __v_147: G = (__v_120 + __v_146); let __v_148: G = (__v_119 + __v_147); let __v_149: G = G::from_bool((__v_148 == G::ZERO)); let __v_150: G = (__v_81 - __v_149); let __v_151: G = (__v_145 * __v_150); let __v_152: G = (__v_81 - __v_151); if (__v_152 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_153: G = G::from_u8(__gb[0]); let __v_154: G = G::from_u8(__gb[1]); let __v_155: G = G::from_u8(__gb[2]); let __v_156: G = G::from_u8(__gb[3]); let __v_157: G = G::from_u8(__gb[4]); let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_161: G = (__v_50 * __v_154); let __v_162: G = (__v_52 * __v_155); let __v_163: G = (__v_54 * __v_156); let __v_164: G = (__v_56 * __v_157); let __v_165: G = (__v_58 * __v_158); let __v_166: G = (__v_60 * __v_159); let __v_167: G = (__v_62 * __v_160); let __v_168: G = (__v_166 + __v_167); let __v_169: G = (__v_165 + __v_168); let __v_170: G = (__v_164 + __v_169); let __v_171: G = (__v_163 + __v_170); let __v_172: G = (__v_162 + __v_171); let __v_173: G = (__v_161 + __v_172); let __v_174: G = (__v_153 + __v_173); if (__v_174 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None }); } let __v_175: G = (__v_160 - __v_71); let __v_176: G = (__v_159 + __v_175); let __v_177: G = (__v_158 + __v_176); let __v_178: G = (__v_157 + __v_177); let __v_179: G = G::from_bool((__v_178 == G::ZERO)); let __v_180: G = (__v_155 + __v_156); let __v_181: G = (__v_154 + __v_180); let __v_182: G = (__v_153 + __v_181); let __v_183: G = G::from_bool((__v_182 == G::ZERO)); let __v_184: G = (__v_81 - __v_183); let __v_185: G = (__v_179 * __v_184); let __v_186: G = (__v_81 - __v_185); if (__v_186 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __v_187: G = G::from_u64(0); let __v_188: G = { let __values: [G; 10] = [__v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_189: G = { let __values: [G; 10] = [__v_187, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_188]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_190: G = { let __values: [G; 10] = [__v_187, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_189]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_191: G = { let __values: [G; 10] = [__v_187, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_190]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_192: G = { let __values: [G; 10] = [__v_187, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_191]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_193: G = { let __values: [G; 3] = [__v_187, __v_192, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_39, __v_40, __v_193]; record.function_queries[155].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } +fn aiur_fn_155(inp: [G; IN_155], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { let __v_13: G = __v_6 - __v_8; let __v_14: G = G::from_bool(__v_13 == G::ZERO); let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, &__args[..])?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __v_18: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_0, __v_1, __v_18]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = __v_6 - __v_25; let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_23.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_0, __v_1, __v_28, __v_29]; }, _ => { break '__mc_0 [__v_28, __v_29, __v_0, __v_1]; }, } }; let __v_30: G = __mc_out___mc_0[0]; let __v_31: G = __mc_out___mc_0[1]; let __v_32: G = __mc_out___mc_0[2]; let __v_33: G = __mc_out___mc_0[3]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(128, &__args[..])?) { [G::ZERO; OUT_128] } else { let (__hash, __hit) = record.function_queries[128].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[128].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => { aiur_fn_128::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(154, &__args[..])?) { [G::ZERO; OUT_154] } else { let (__hash, __hit) = record.function_queries[154].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[154].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => { aiur_fn_154::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_36, __v_37, __v_16, __v_19, __v_12, __v_24, __v_26, __v_38, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, &__args[..])?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); let __v_42: G = G::from_u8(__gb[0]); let __v_43: G = G::from_u8(__gb[1]); let __v_44: G = G::from_u8(__gb[2]); let __v_45: G = G::from_u8(__gb[3]); let __v_46: G = G::from_u8(__gb[4]); let __v_47: G = G::from_u8(__gb[5]); let __v_48: G = G::from_u8(__gb[6]); let __v_49: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_48; let __vj = __v_49; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_50: G = G::from_u64(256); let __v_51: G = __v_50 * __v_43; let __v_52: G = G::from_u64(65536); let __v_53: G = __v_52 * __v_44; let __v_54: G = G::from_u64(16777216); let __v_55: G = __v_54 * __v_45; let __v_56: G = G::from_u64(4294967296); let __v_57: G = __v_56 * __v_46; let __v_58: G = G::from_u64(1099511627776); let __v_59: G = __v_58 * __v_47; let __v_60: G = G::from_u64(281474976710656); let __v_61: G = __v_60 * __v_48; let __v_62: G = G::from_u64(72057594037927936); let __v_63: G = __v_62 * __v_49; let __v_64: G = __v_61 + __v_63; let __v_65: G = __v_59 + __v_64; let __v_66: G = __v_57 + __v_65; let __v_67: G = __v_55 + __v_66; let __v_68: G = __v_53 + __v_67; let __v_69: G = __v_51 + __v_68; let __v_70: G = __v_42 + __v_69; if (__v_70 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __v_71: G = G::from_u64(1020); let __v_72: G = __v_49 - __v_71; let __v_73: G = __v_48 + __v_72; let __v_74: G = __v_47 + __v_73; let __v_75: G = __v_46 + __v_74; let __v_76: G = G::from_bool(__v_75 == G::ZERO); let __v_77: G = __v_44 + __v_45; let __v_78: G = __v_43 + __v_77; let __v_79: G = __v_42 + __v_78; let __v_80: G = G::from_bool(__v_79 == G::ZERO); let __v_81: G = G::from_u64(1); let __v_82: G = __v_81 - __v_80; let __v_83: G = __v_76 * __v_82; let __v_84: G = __v_81 - __v_83; if (__v_84 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); let __v_85: G = G::from_u8(__gb[0]); let __v_86: G = G::from_u8(__gb[1]); let __v_87: G = G::from_u8(__gb[2]); let __v_88: G = G::from_u8(__gb[3]); let __v_89: G = G::from_u8(__gb[4]); let __v_90: G = G::from_u8(__gb[5]); let __v_91: G = G::from_u8(__gb[6]); let __v_92: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_85; let __vj = __v_86; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_93: G = __v_50 * __v_86; let __v_94: G = __v_52 * __v_87; let __v_95: G = __v_54 * __v_88; let __v_96: G = __v_56 * __v_89; let __v_97: G = __v_58 * __v_90; let __v_98: G = __v_60 * __v_91; let __v_99: G = __v_62 * __v_92; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_97 + __v_100; let __v_102: G = __v_96 + __v_101; let __v_103: G = __v_95 + __v_102; let __v_104: G = __v_94 + __v_103; let __v_105: G = __v_93 + __v_104; let __v_106: G = __v_85 + __v_105; if (__v_106 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_106.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_107: G = __v_92 - __v_71; let __v_108: G = __v_91 + __v_107; let __v_109: G = __v_90 + __v_108; let __v_110: G = __v_89 + __v_109; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_87 + __v_88; let __v_113: G = __v_86 + __v_112; let __v_114: G = __v_85 + __v_113; let __v_115: G = G::from_bool(__v_114 == G::ZERO); let __v_116: G = __v_81 - __v_115; let __v_117: G = __v_111 * __v_116; let __v_118: G = __v_81 - __v_117; if (__v_118 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); let __v_119: G = G::from_u8(__gb[0]); let __v_120: G = G::from_u8(__gb[1]); let __v_121: G = G::from_u8(__gb[2]); let __v_122: G = G::from_u8(__gb[3]); let __v_123: G = G::from_u8(__gb[4]); let __v_124: G = G::from_u8(__gb[5]); let __v_125: G = G::from_u8(__gb[6]); let __v_126: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_119; let __vj = __v_120; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_121; let __vj = __v_122; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_123; let __vj = __v_124; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_125; let __vj = __v_126; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_127: G = __v_50 * __v_120; let __v_128: G = __v_52 * __v_121; let __v_129: G = __v_54 * __v_122; let __v_130: G = __v_56 * __v_123; let __v_131: G = __v_58 * __v_124; let __v_132: G = __v_60 * __v_125; let __v_133: G = __v_62 * __v_126; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_131 + __v_134; let __v_136: G = __v_130 + __v_135; let __v_137: G = __v_129 + __v_136; let __v_138: G = __v_128 + __v_137; let __v_139: G = __v_127 + __v_138; let __v_140: G = __v_119 + __v_139; if (__v_140 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_141: G = __v_126 - __v_71; let __v_142: G = __v_125 + __v_141; let __v_143: G = __v_124 + __v_142; let __v_144: G = __v_123 + __v_143; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_121 + __v_122; let __v_147: G = __v_120 + __v_146; let __v_148: G = __v_119 + __v_147; let __v_149: G = G::from_bool(__v_148 == G::ZERO); let __v_150: G = __v_81 - __v_149; let __v_151: G = __v_145 * __v_150; let __v_152: G = __v_81 - __v_151; if (__v_152 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_153: G = G::from_u8(__gb[0]); let __v_154: G = G::from_u8(__gb[1]); let __v_155: G = G::from_u8(__gb[2]); let __v_156: G = G::from_u8(__gb[3]); let __v_157: G = G::from_u8(__gb[4]); let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_161: G = __v_50 * __v_154; let __v_162: G = __v_52 * __v_155; let __v_163: G = __v_54 * __v_156; let __v_164: G = __v_56 * __v_157; let __v_165: G = __v_58 * __v_158; let __v_166: G = __v_60 * __v_159; let __v_167: G = __v_62 * __v_160; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_165 + __v_168; let __v_170: G = __v_164 + __v_169; let __v_171: G = __v_163 + __v_170; let __v_172: G = __v_162 + __v_171; let __v_173: G = __v_161 + __v_172; let __v_174: G = __v_153 + __v_173; if (__v_174 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None }); } let __v_175: G = __v_160 - __v_71; let __v_176: G = __v_159 + __v_175; let __v_177: G = __v_158 + __v_176; let __v_178: G = __v_157 + __v_177; let __v_179: G = G::from_bool(__v_178 == G::ZERO); let __v_180: G = __v_155 + __v_156; let __v_181: G = __v_154 + __v_180; let __v_182: G = __v_153 + __v_181; let __v_183: G = G::from_bool(__v_182 == G::ZERO); let __v_184: G = __v_81 - __v_183; let __v_185: G = __v_179 * __v_184; let __v_186: G = __v_81 - __v_185; if (__v_186 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None }); } let __v_187: G = G::from_u64(0); let __v_188: G = { let __values: [G; 10] = [__v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_189: G = { let __values: [G; 10] = [__v_187, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_188]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_190: G = { let __values: [G; 10] = [__v_187, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_189]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_191: G = { let __values: [G; 10] = [__v_187, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_190]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_192: G = { let __values: [G; 10] = [__v_187, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_191]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_193: G = { let __values: [G; 3] = [__v_187, __v_192, __v_41]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_155] = [__v_39, __v_40, __v_193]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } const INPUT_SIZE_156: usize = 25; const IN_156: usize = 25; const OUT_156: usize = 1; -fn aiur_fn_156(inp: [G; IN_156], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_24); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_30 + __v_31); let __v_33: G = (__v_29 - __v_32); let __v_34: G = G::from_bool((__v_33 == G::ZERO)); if (__v_34 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, (&__args[..]))?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { (*(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139])) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_39 - __v_18); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_43: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_35, __v_0, __v_20, __v_19, __v_43, __v_18, __v_15, __v_16, __v_17, __v_38, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_46 - __v_18); let __v_48: G = G::from_bool((__v_47 == G::ZERO)); let __v_49: G = G::from_u64(1); if (__v_48 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None }); } let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_44, __v_0, __v_20, __v_19, __v_50, __v_18, __v_15, __v_16, __v_17, __v_45, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, (&__args[..]))?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { (*(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145])) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_54 - __v_18); let __v_56: G = G::from_bool((__v_55 == G::ZERO)); let __v_57: G = G::from_u64(1); if (__v_56 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None }); } let __v_58: G = G::from_u64(0); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_51, __v_0, __v_20, __v_19, __v_58, __v_18, __v_15, __v_16, __v_17, __v_53, __v_7, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, (&__args[..]))?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { (*(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146])) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_59, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, (&__args[..]))?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { (*(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148])) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_60, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, (&__args[..]))?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { (*(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141])) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_62: G = __loaded[0]; let __v_63: G = __loaded[1]; let __v_64: G = __loaded[2]; let __v_65: G = __loaded[3]; let __v_66: G = __loaded[4]; let __v_67: G = __loaded[5]; let __v_68: G = __loaded[6]; match __v_62.as_canonical_u64() { 0u64 => { match __v_63.as_canonical_u64() { _ => { let __v_69: G = (__v_63 - __v_20); let __v_70: G = G::from_bool((__v_69 == G::ZERO)); let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_66, __v_67, __v_21, __v_22, __v_2, __v_0, __v_20, __v_68, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, (&__args[..]))?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { (*(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155])) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_23, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = (__v_76 - __v_72); let __v_79: G = G::from_bool((__v_78 == G::ZERO)); let __v_80: G = (__v_77 - __v_73); let __v_81: G = G::from_bool((__v_80 == G::ZERO)); let __v_82: G = (__v_79 * __v_81); if (__v_82 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_156] = [__v_74]; record.function_queries[156].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } +fn aiur_fn_156(inp: [G; IN_156], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __v_25 - __v_24; let __v_27: G = G::from_bool(__v_26 == G::ZERO); let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __v_30 + __v_31; let __v_33: G = __v_29 - __v_32; let __v_34: G = G::from_bool(__v_33 == G::ZERO); if (__v_34 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(139, &__args[..])?) { [G::ZERO; OUT_139] } else { let (__hash, __hit) = record.function_queries[139].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[139].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => { aiur_fn_139::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __v_39 - __v_18; let __v_41: G = G::from_bool(__v_40 == G::ZERO); let __v_42: G = G::from_u64(1); if (__v_41 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_43: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_35, __v_0, __v_20, __v_19, __v_43, __v_18, __v_15, __v_16, __v_17, __v_38, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __v_46 - __v_18; let __v_48: G = G::from_bool(__v_47 == G::ZERO); let __v_49: G = G::from_u64(1); if (__v_48 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None }); } let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_44, __v_0, __v_20, __v_19, __v_50, __v_18, __v_15, __v_16, __v_17, __v_45, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(145, &__args[..])?) { [G::ZERO; OUT_145] } else { let (__hash, __hit) = record.function_queries[145].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[145].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => { aiur_fn_145::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __v_54 - __v_18; let __v_56: G = G::from_bool(__v_55 == G::ZERO); let __v_57: G = G::from_u64(1); if (__v_56 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None }); } let __v_58: G = G::from_u64(0); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_51, __v_0, __v_20, __v_19, __v_58, __v_18, __v_15, __v_16, __v_17, __v_53, __v_7, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(146, &__args[..])?) { [G::ZERO; OUT_146] } else { let (__hash, __hit) = record.function_queries[146].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[146].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => { aiur_fn_146::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_59, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(148, &__args[..])?) { [G::ZERO; OUT_148] } else { let (__hash, __hit) = record.function_queries[148].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[148].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => { aiur_fn_148::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_60, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(141, &__args[..])?) { [G::ZERO; OUT_141] } else { let (__hash, __hit) = record.function_queries[141].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[141].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => { aiur_fn_141::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_62: G = __loaded[0]; let __v_63: G = __loaded[1]; let __v_64: G = __loaded[2]; let __v_65: G = __loaded[3]; let __v_66: G = __loaded[4]; let __v_67: G = __loaded[5]; let __v_68: G = __loaded[6]; match __v_62.as_canonical_u64() { 0u64 => { match __v_63.as_canonical_u64() { _ => { let __v_69: G = __v_63 - __v_20; let __v_70: G = G::from_bool(__v_69 == G::ZERO); let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_66, __v_67, __v_21, __v_22, __v_2, __v_0, __v_20, __v_68, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(155, &__args[..])?) { [G::ZERO; OUT_155] } else { let (__hash, __hit) = record.function_queries[155].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[155].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => { aiur_fn_155::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_23, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = __v_76 - __v_72; let __v_79: G = G::from_bool(__v_78 == G::ZERO); let __v_80: G = __v_77 - __v_73; let __v_81: G = G::from_bool(__v_80 == G::ZERO); let __v_82: G = __v_79 * __v_81; if (__v_82 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_156] = [__v_74]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } const INPUT_SIZE_157: usize = 25; const IN_157: usize = 25; const OUT_157: usize = 1; -fn aiur_fn_157(inp: [G; IN_157], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_30]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(156, (&__args[..]))?) { [G::ZERO; OUT_156] } else { let (__hash, __hit) = record.function_queries[156].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[156].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { (*(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156])) }; __ret }, _ => { aiur_fn_156::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_35]; record.function_queries[157].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } +fn aiur_fn_157(inp: [G; IN_157], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_30]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(156, &__args[..])?) { [G::ZERO; OUT_156] } else { let (__hash, __hit) = record.function_queries[156].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[156].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => { aiur_fn_156::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_157] = [__v_35]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } const INPUT_SIZE_158: usize = 4; const IN_158: usize = 4; const OUT_158: usize = 1; -fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_5]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, (&__args[..]))?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { (*(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176])) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_11]; record.function_queries[158].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_158(inp: [G; IN_158], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_5]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(176, &__args[..])?) { [G::ZERO; OUT_176] } else { let (__hash, __hit) = record.function_queries[176].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[176].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => { aiur_fn_176::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = __v_2 - __v_8; let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_158] = [__v_11]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_159: usize = 2; const IN_159: usize = 2; const OUT_159: usize = 1; -fn aiur_fn_159(inp: [G; IN_159], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_7]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, (&__args[..]))?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { (*(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159])) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_9]; record.function_queries[159].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_159(inp: [G; IN_159], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_7]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, &__args[..])?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_159] = [__v_9]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_160: usize = 2; const IN_160: usize = 2; const OUT_160: usize = 1; -fn aiur_fn_160(inp: [G; IN_160], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_8]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_10]; record.function_queries[160].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_160(inp: [G; IN_160], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_8]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_160] = [__v_10]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_161: usize = 4; const IN_161: usize = 4; const OUT_161: usize = 1; -fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_5]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, (&__args[..]))?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { (*(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159])) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, (&__args[..]))?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { (*(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160])) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __v_9: G = (__v_3 - __v_7); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_11]; record.function_queries[161].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_161(inp: [G; IN_161], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_5]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(159, &__args[..])?) { [G::ZERO; OUT_159] } else { let (__hash, __hit) = record.function_queries[159].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[159].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => { aiur_fn_159::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(160, &__args[..])?) { [G::ZERO; OUT_160] } else { let (__hash, __hit) = record.function_queries[160].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[160].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => { aiur_fn_160::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_2 + __v_7; let __v_9: G = __v_3 - __v_7; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_161] = [__v_11]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_162: usize = 13; const IN_162: usize = 13; const OUT_162: usize = 1; -fn aiur_fn_162(inp: [G; IN_162], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, (&__args[..]))?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { (*(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149])) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_6.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_162] = [__v_27]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_9, __v_11, __v_8, __v_10, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, (&__args[..]))?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { (*(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151])) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, (&__args[..]))?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { (*(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150])) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_12 - __v_32); let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_35]; record.function_queries[162].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } +fn aiur_fn_162(inp: [G; IN_162], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(149, &__args[..])?) { [G::ZERO; OUT_149] } else { let (__hash, __hit) = record.function_queries[149].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[149].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => { aiur_fn_149::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } match __v_6.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_162] = [__v_27]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_9, __v_11, __v_8, __v_10, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(151, &__args[..])?) { [G::ZERO; OUT_151] } else { let (__hash, __hit) = record.function_queries[151].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[151].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => { aiur_fn_151::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(150, &__args[..])?) { [G::ZERO; OUT_150] } else { let (__hash, __hit) = record.function_queries[150].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[150].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => { aiur_fn_150::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __v_12 - __v_32; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_35]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } const INPUT_SIZE_163: usize = 2; const IN_163: usize = 2; const OUT_163: usize = 1; -fn aiur_fn_163(inp: [G; IN_163], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_163] = [__v_0]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_8]; record.function_queries[163].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_163(inp: [G; IN_163], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_163] = [__v_0]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_163] = [__v_8]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_164: usize = 2; const IN_164: usize = 2; const OUT_164: usize = 1; -fn aiur_fn_164(inp: [G; IN_164], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_6]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_164(inp: [G; IN_164], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_6]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_164] = [__v_11]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_165: usize = 6; const IN_165: usize = 6; const OUT_165: usize = 1; -fn aiur_fn_165(inp: [G; IN_165], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool((__v_11 == G::ZERO)); let __ret: [G; OUT_165] = [__v_12]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, (&__args[..]))?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { (*(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163])) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_14); let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, (&__args[..]))?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { (*(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164])) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_18, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, (&__args[..]))?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { (*(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125])) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_24: G = (__v_4 + __v_14); let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_25]; record.function_queries[165].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } +fn aiur_fn_165(inp: [G; IN_165], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool(__v_11 == G::ZERO); let __ret: [G; OUT_165] = [__v_12]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); if (__v_7 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(163, &__args[..])?) { [G::ZERO; OUT_163] } else { let (__hash, __hit) = record.function_queries[163].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[163].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => { aiur_fn_163::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_5 - __v_14; let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(164, &__args[..])?) { [G::ZERO; OUT_164] } else { let (__hash, __hit) = record.function_queries[164].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[164].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => { aiur_fn_164::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_18, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(125, &__args[..])?) { [G::ZERO; OUT_125] } else { let (__hash, __hit) = record.function_queries[125].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[125].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => { aiur_fn_125::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } let __v_24: G = __v_4 + __v_14; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_25]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } const INPUT_SIZE_166: usize = 32; const IN_166: usize = 32; const OUT_166: usize = 1; -fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = (__v_33 - __v_32); let __v_35: G = G::from_bool((__v_34 == G::ZERO)); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_38 + __v_39); if (__v_37 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_41 - __v_32); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); if (__v_43 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; if (__v_44 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __v_45: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_45]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; break '__mc_0 [__v_46]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; let __v_46: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __v_71: G = G::from_u64(256); let __v_72: G = (__v_71 * __v_54); let __v_73: G = G::from_u64(65536); let __v_74: G = (__v_73 * __v_55); let __v_75: G = G::from_u64(16777216); let __v_76: G = (__v_75 * __v_56); let __v_77: G = G::from_u64(4294967296); let __v_78: G = (__v_77 * __v_57); let __v_79: G = G::from_u64(1099511627776); let __v_80: G = (__v_79 * __v_58); let __v_81: G = G::from_u64(281474976710656); let __v_82: G = (__v_81 * __v_59); let __v_83: G = G::from_u64(72057594037927936); let __v_84: G = (__v_83 * __v_60); let __v_85: G = (__v_82 + __v_84); let __v_86: G = (__v_80 + __v_85); let __v_87: G = (__v_78 + __v_86); let __v_88: G = (__v_76 + __v_87); let __v_89: G = (__v_74 + __v_88); let __v_90: G = (__v_72 + __v_89); let __v_91: G = (__v_53 + __v_90); let __v_92: G = (__v_71 * __v_62); let __v_93: G = (__v_73 * __v_63); let __v_94: G = (__v_75 * __v_64); let __v_95: G = (__v_77 * __v_65); let __v_96: G = (__v_79 * __v_66); let __v_97: G = (__v_81 * __v_67); let __v_98: G = (__v_83 * __v_68); let __v_99: G = (__v_97 + __v_98); let __v_100: G = (__v_96 + __v_99); let __v_101: G = (__v_95 + __v_100); let __v_102: G = (__v_94 + __v_101); let __v_103: G = (__v_93 + __v_102); let __v_104: G = (__v_92 + __v_103); let __v_105: G = (__v_61 + __v_104); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_69, __v_6, __v_7, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, (&__args[..]))?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { (*(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137])) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_109, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_110: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = (__v_32 + __v_28); let __v_114: G = G::from_u64(33); let __v_115: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_114.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; if (__v_115 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_111, __v_112, __v_29, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_116: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_116, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, (&__args[..]))?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { (*(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162])) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_117: G = __r_arr[0]; if (__v_117 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __v_118: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_111, __v_112, __v_119, __v_91, __v_105, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_113, __v_106, __v_6, __v_10, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_121: G = __r_arr[0]; let __ret: [G; OUT_166] = [__v_121]; record.function_queries[166].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_166(inp: [G; IN_166], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __v_33 - __v_32; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __v_38 + __v_39; if (__v_37 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __v_41 - __v_32; let __v_43: G = G::from_bool(__v_42 == G::ZERO); if (__v_43 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; if (__v_44 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __v_45: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_45]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; break '__mc_0 [__v_46]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; let __v_46: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __v_71: G = G::from_u64(256); let __v_72: G = __v_71 * __v_54; let __v_73: G = G::from_u64(65536); let __v_74: G = __v_73 * __v_55; let __v_75: G = G::from_u64(16777216); let __v_76: G = __v_75 * __v_56; let __v_77: G = G::from_u64(4294967296); let __v_78: G = __v_77 * __v_57; let __v_79: G = G::from_u64(1099511627776); let __v_80: G = __v_79 * __v_58; let __v_81: G = G::from_u64(281474976710656); let __v_82: G = __v_81 * __v_59; let __v_83: G = G::from_u64(72057594037927936); let __v_84: G = __v_83 * __v_60; let __v_85: G = __v_82 + __v_84; let __v_86: G = __v_80 + __v_85; let __v_87: G = __v_78 + __v_86; let __v_88: G = __v_76 + __v_87; let __v_89: G = __v_74 + __v_88; let __v_90: G = __v_72 + __v_89; let __v_91: G = __v_53 + __v_90; let __v_92: G = __v_71 * __v_62; let __v_93: G = __v_73 * __v_63; let __v_94: G = __v_75 * __v_64; let __v_95: G = __v_77 * __v_65; let __v_96: G = __v_79 * __v_66; let __v_97: G = __v_81 * __v_67; let __v_98: G = __v_83 * __v_68; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_96 + __v_99; let __v_101: G = __v_95 + __v_100; let __v_102: G = __v_94 + __v_101; let __v_103: G = __v_93 + __v_102; let __v_104: G = __v_92 + __v_103; let __v_105: G = __v_61 + __v_104; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_69, __v_6, __v_7, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, &__args[..])?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_109, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_110: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = __v_32 + __v_28; let __v_114: G = G::from_u64(33); let __v_115: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_114.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; if (__v_115 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_111, __v_112, __v_29, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_116: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_116, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, &__args[..])?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_117: G = __r_arr[0]; if (__v_117 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None }); } let __v_118: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_111, __v_112, __v_119, __v_91, __v_105, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_113, __v_106, __v_6, __v_10, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_121: G = __r_arr[0]; let __ret: [G; OUT_166] = [__v_121]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_167: usize = 2; const IN_167: usize = 2; const OUT_167: usize = 1; -fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool((__v_0 == G::ZERO)); let __v_3: G = G::from_bool((__v_1 == G::ZERO)); let __v_4: G = (__v_2 * __v_3); let __ret: [G; OUT_167] = [__v_4]; record.function_queries[167].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_167(inp: [G; IN_167], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool(__v_0 == G::ZERO); let __v_3: G = G::from_bool(__v_1 == G::ZERO); let __v_4: G = __v_2 * __v_3; let __ret: [G; OUT_167] = [__v_4]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_168: usize = 9; const IN_168: usize = 9; const OUT_168: usize = 1; -fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 3] = [__v_9, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 3] = [__v_9, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_9, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_0, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_168] = [__v_17]; record.function_queries[168].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_168(inp: [G; IN_168], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 3] = [__v_9, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 3] = [__v_9, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_9, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_0, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_168] = [__v_17]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_169: usize = 33; const IN_169: usize = 33; const OUT_169: usize = 1; -fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_36]; record.function_queries[169].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_169(inp: [G; IN_169], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_36]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_170: usize = 2; const IN_170: usize = 2; const OUT_170: usize = 1; -fn aiur_fn_170(inp: [G; IN_170], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_170] = [__v_1]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __v_23: G = __loaded[18]; let __v_24: G = __loaded[19]; let __v_25: G = __loaded[20]; let __v_26: G = __loaded[21]; let __v_27: G = __loaded[22]; let __v_28: G = __loaded[23]; let __v_29: G = __loaded[24]; let __v_30: G = __loaded[25]; let __v_31: G = __loaded[26]; let __v_32: G = __loaded[27]; let __v_33: G = __loaded[28]; let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_41]; record.function_queries[170].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_170(inp: [G; IN_170], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_170] = [__v_1]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __v_23: G = __loaded[18]; let __v_24: G = __loaded[19]; let __v_25: G = __loaded[20]; let __v_26: G = __loaded[21]; let __v_27: G = __loaded[22]; let __v_28: G = __loaded[23]; let __v_29: G = __loaded[24]; let __v_30: G = __loaded[25]; let __v_31: G = __loaded[26]; let __v_32: G = __loaded[27]; let __v_33: G = __loaded[28]; let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_41]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_171: usize = 2; const IN_171: usize = 2; const OUT_171: usize = 1; -fn aiur_fn_171(inp: [G; IN_171], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_171] = [__v_1]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_7]; record.function_queries[171].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_171(inp: [G; IN_171], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_171] = [__v_1]; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_7]; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_172: usize = 2; const IN_172: usize = 2; const OUT_172: usize = 10; -fn aiur_fn_172(inp: [G; IN_172], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(103); let __v_6: G = G::from_u64(230); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(106); let __v_9: G = G::from_u64(133); let __v_10: G = G::from_u64(174); let __v_11: G = G::from_u64(187); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(243); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(165); let __v_20: G = G::from_u64(127); let __v_21: G = G::from_u64(82); let __v_22: G = G::from_u64(14); let __v_23: G = G::from_u64(81); let __v_24: G = G::from_u64(140); let __v_25: G = G::from_u64(104); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(31); let __v_32: G = G::from_u64(25); let __v_33: G = G::from_u64(205); let __v_34: G = G::from_u64(224); let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 8] = [__v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 34] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = __r_arr[2]; let __v_46: G = __r_arr[3]; let __v_47: G = __r_arr[4]; let __v_48: G = __r_arr[5]; let __v_49: G = __r_arr[6]; let __v_50: G = __r_arr[7]; let __v_51: G = __r_arr[8]; let __v_52: G = __r_arr[9]; let __v_53: G = __r_arr[10]; let __v_54: G = __r_arr[11]; let __v_55: G = __r_arr[12]; let __v_56: G = __r_arr[13]; let __v_57: G = __r_arr[14]; let __v_58: G = __r_arr[15]; let __v_59: G = __r_arr[16]; let __v_60: G = __r_arr[17]; let __v_61: G = __r_arr[18]; let __v_62: G = __r_arr[19]; let __v_63: G = __r_arr[20]; let __v_64: G = __r_arr[21]; let __v_65: G = __r_arr[22]; let __v_66: G = __r_arr[23]; let __v_67: G = __r_arr[24]; let __v_68: G = __r_arr[25]; let __v_69: G = __r_arr[26]; let __v_70: G = __r_arr[27]; let __v_71: G = __r_arr[28]; let __v_72: G = __r_arr[29]; let __v_73: G = __r_arr[30]; let __v_74: G = __r_arr[31]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_71, __v_72, __v_73, __v_74, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_67, __v_68, __v_69, __v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_63, __v_64, __v_65, __v_66, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_59, __v_60, __v_61, __v_62, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_51, __v_52, __v_53, __v_54, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48, __v_49, __v_50, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_43, __v_44, __v_45, __v_46, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, (&__args[..]))?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { (*(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105])) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, (&__args[..]))?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { (*(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126])) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_83.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; match __v_84.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; match __v_87.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_89.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_90: G = __loaded[0]; let __v_91: G = __loaded[1]; let __v_92: G = __loaded[2]; match __v_90.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; match __v_93.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_95.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_96: G = __loaded[0]; let __v_97: G = __loaded[1]; let __v_98: G = __loaded[2]; match __v_96.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_99: G = __loaded[0]; let __v_100: G = __loaded[1]; let __v_101: G = __loaded[2]; match __v_99.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_101.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_102: G = __loaded[0]; let __v_103: G = __loaded[1]; let __v_104: G = __loaded[2]; match __v_102.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_105: G = __loaded[0]; let __v_106: G = __loaded[1]; let __v_107: G = __loaded[2]; match __v_105.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_105.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_99.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_96.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_93.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_90.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_87.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_84.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[172].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_172(inp: [G; IN_172], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(103); let __v_6: G = G::from_u64(230); let __v_7: G = G::from_u64(9); let __v_8: G = G::from_u64(106); let __v_9: G = G::from_u64(133); let __v_10: G = G::from_u64(174); let __v_11: G = G::from_u64(187); let __v_12: G = G::from_u64(114); let __v_13: G = G::from_u64(243); let __v_14: G = G::from_u64(110); let __v_15: G = G::from_u64(60); let __v_16: G = G::from_u64(58); let __v_17: G = G::from_u64(245); let __v_18: G = G::from_u64(79); let __v_19: G = G::from_u64(165); let __v_20: G = G::from_u64(127); let __v_21: G = G::from_u64(82); let __v_22: G = G::from_u64(14); let __v_23: G = G::from_u64(81); let __v_24: G = G::from_u64(140); let __v_25: G = G::from_u64(104); let __v_26: G = G::from_u64(5); let __v_27: G = G::from_u64(155); let __v_28: G = G::from_u64(171); let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(31); let __v_32: G = G::from_u64(25); let __v_33: G = G::from_u64(205); let __v_34: G = G::from_u64(224); let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 8] = [__v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_40: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_41: G = { let __values: [G; 34] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = __r_arr[2]; let __v_46: G = __r_arr[3]; let __v_47: G = __r_arr[4]; let __v_48: G = __r_arr[5]; let __v_49: G = __r_arr[6]; let __v_50: G = __r_arr[7]; let __v_51: G = __r_arr[8]; let __v_52: G = __r_arr[9]; let __v_53: G = __r_arr[10]; let __v_54: G = __r_arr[11]; let __v_55: G = __r_arr[12]; let __v_56: G = __r_arr[13]; let __v_57: G = __r_arr[14]; let __v_58: G = __r_arr[15]; let __v_59: G = __r_arr[16]; let __v_60: G = __r_arr[17]; let __v_61: G = __r_arr[18]; let __v_62: G = __r_arr[19]; let __v_63: G = __r_arr[20]; let __v_64: G = __r_arr[21]; let __v_65: G = __r_arr[22]; let __v_66: G = __r_arr[23]; let __v_67: G = __r_arr[24]; let __v_68: G = __r_arr[25]; let __v_69: G = __r_arr[26]; let __v_70: G = __r_arr[27]; let __v_71: G = __r_arr[28]; let __v_72: G = __r_arr[29]; let __v_73: G = __r_arr[30]; let __v_74: G = __r_arr[31]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_71, __v_72, __v_73, __v_74, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_67, __v_68, __v_69, __v_70, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_63, __v_64, __v_65, __v_66, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_59, __v_60, __v_61, __v_62, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_51, __v_52, __v_53, __v_54, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48, __v_49, __v_50, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_43, __v_44, __v_45, __v_46, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(105, &__args[..])?) { [G::ZERO; OUT_105] } else { let (__hash, __hit) = record.function_queries[105].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[105].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => { aiur_fn_105::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(126, &__args[..])?) { [G::ZERO; OUT_126] } else { let (__hash, __hit) = record.function_queries[126].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[126].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => { aiur_fn_126::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_83.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; match __v_84.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; match __v_87.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_89.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_90: G = __loaded[0]; let __v_91: G = __loaded[1]; let __v_92: G = __loaded[2]; match __v_90.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; match __v_93.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_95.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_96: G = __loaded[0]; let __v_97: G = __loaded[1]; let __v_98: G = __loaded[2]; match __v_96.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_99: G = __loaded[0]; let __v_100: G = __loaded[1]; let __v_101: G = __loaded[2]; match __v_99.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_101.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_102: G = __loaded[0]; let __v_103: G = __loaded[1]; let __v_104: G = __loaded[2]; match __v_102.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_105: G = __loaded[0]; let __v_106: G = __loaded[1]; let __v_107: G = __loaded[2]; match __v_105.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_105.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_99.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_96.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_93.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_90.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_87.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_84.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_172] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_173: usize = 2; const IN_173: usize = 2; const OUT_173: usize = 10; -fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, (&__args[..]))?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { (*(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172])) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1020); let __v_13: G = (__v_9 - __v_12); let __v_14: G = (__v_8 + __v_13); let __v_15: G = (__v_7 + __v_14); let __v_16: G = (__v_6 + __v_15); let __v_17: G = G::from_bool((__v_16 == G::ZERO)); let __v_18: G = (__v_4 + __v_5); let __v_19: G = (__v_3 + __v_18); let __v_20: G = (__v_2 + __v_19); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); let __v_22: G = G::from_u64(1); let __v_23: G = (__v_22 - __v_21); let __v_24: G = (__v_17 * __v_23); let __v_25: G = (__v_22 - __v_24); match __v_25.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_173] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = __r_arr[9]; let __ret: [G; OUT_173] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[173].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_173(inp: [G; IN_173], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, &__args[..])?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(1020); let __v_13: G = __v_9 - __v_12; let __v_14: G = __v_8 + __v_13; let __v_15: G = __v_7 + __v_14; let __v_16: G = __v_6 + __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = __v_4 + __v_5; let __v_19: G = __v_3 + __v_18; let __v_20: G = __v_2 + __v_19; let __v_21: G = G::from_bool(__v_20 == G::ZERO); let __v_22: G = G::from_u64(1); let __v_23: G = __v_22 - __v_21; let __v_24: G = __v_17 * __v_23; let __v_25: G = __v_22 - __v_24; match __v_25.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_173] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = __r_arr[9]; let __ret: [G; OUT_173] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_174: usize = 2; const IN_174: usize = 2; const OUT_174: usize = 18; -fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, (&__args[..]))?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { (*(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173])) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_174] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[174].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_174(inp: [G; IN_174], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(173, &__args[..])?) { [G::ZERO; OUT_173] } else { let (__hash, __hit) = record.function_queries[173].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[173].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => { aiur_fn_173::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __v_15: G = __r_arr[3]; let __v_16: G = __r_arr[4]; let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_174] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_175: usize = 2; const IN_175: usize = 2; const OUT_175: usize = 1; -fn aiur_fn_175(inp: [G; IN_175], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_3]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_9]; record.function_queries[175].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_175(inp: [G; IN_175], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_3]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, &__args[..])?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_175] = [__v_9]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_176: usize = 3; const IN_176: usize = 3; const OUT_176: usize = 3; -fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, (&__args[..]))?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { (*(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172])) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_3)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_3, record) }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; let __v_16: G = __b1_out[3]; let __v_17: G = __b1_out[4]; let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_4)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_4, record) }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; let __v_24: G = __b1_out[3]; let __v_25: G = __b1_out[4]; let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_5)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_5, record) }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; let __v_32: G = __b1_out[3]; let __v_33: G = __b1_out[4]; let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose((&__v_6)); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_6, record) }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; let __v_40: G = __b1_out[3]; let __v_41: G = __b1_out[4]; let __v_42: G = __b1_out[5]; let __v_43: G = __b1_out[6]; let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, (&__args[..]))?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { (*(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175])) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_51, __v_11, __v_12]; record.function_queries[176].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_176(inp: [G; IN_176], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(172, &__args[..])?) { [G::ZERO; OUT_172] } else { let (__hash, __hit) = record.function_queries[172].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[172].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => { aiur_fn_172::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_3, record) }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; let __v_16: G = __b1_out[3]; let __v_17: G = __b1_out[4]; let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_4, record) }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; let __v_24: G = __b1_out[3]; let __v_25: G = __b1_out[4]; let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_5, record) }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; let __v_32: G = __b1_out[3]; let __v_33: G = __b1_out[4]; let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_6, record) }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; let __v_40: G = __b1_out[3]; let __v_41: G = __b1_out[4]; let __v_42: G = __b1_out[5]; let __v_43: G = __b1_out[6]; let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 3] = [__v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(175, &__args[..])?) { [G::ZERO; OUT_175] } else { let (__hash, __hit) = record.function_queries[175].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[175].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => { aiur_fn_175::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_51, __v_11, __v_12]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_177: usize = 9; const IN_177: usize = 9; const OUT_177: usize = 1; -fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_177] = [__v_12]; record.function_queries[177].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_177(inp: [G; IN_177], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_177] = [__v_12]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_178: usize = 2; const IN_178: usize = 2; const OUT_178: usize = 1; -fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_5]; record.function_queries[178].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_178(inp: [G; IN_178], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_5]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_179: usize = 1; const IN_179: usize = 1; const OUT_179: usize = 1; -fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(108); let __v_5: G = G::from_u64(116); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(45); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(107); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(118); let __v_14: G = G::from_u64(48); let __v_15: G = { let __values: [G; 3] = [__v_1, __v_14, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_1, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_1, __v_12, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 3] = [__v_1, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_10, __v_18]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_20: G = { let __values: [G; 3] = [__v_1, __v_9, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_21: G = { let __values: [G; 3] = [__v_1, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_1, __v_8, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_23: G = { let __values: [G; 3] = [__v_1, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_24: G = { let __values: [G; 3] = [__v_1, __v_6, __v_23]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_25: G = { let __values: [G; 3] = [__v_1, __v_5, __v_24]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_26: G = { let __values: [G; 3] = [__v_1, __v_4, __v_25]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_1, __v_3, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_1, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_179] = [__v_28]; record.function_queries[179].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_179(inp: [G; IN_179], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(117); let __v_4: G = G::from_u64(108); let __v_5: G = G::from_u64(116); let __v_6: G = G::from_u64(105); let __v_7: G = G::from_u64(45); let __v_8: G = G::from_u64(115); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(114); let __v_11: G = G::from_u64(107); let __v_12: G = G::from_u64(47); let __v_13: G = G::from_u64(118); let __v_14: G = G::from_u64(48); let __v_15: G = { let __values: [G; 3] = [__v_1, __v_14, __v_0]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 3] = [__v_1, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 3] = [__v_1, __v_12, __v_16]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 3] = [__v_1, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_10, __v_18]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_20: G = { let __values: [G; 3] = [__v_1, __v_9, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_21: G = { let __values: [G; 3] = [__v_1, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_22: G = { let __values: [G; 3] = [__v_1, __v_8, __v_21]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_23: G = { let __values: [G; 3] = [__v_1, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_24: G = { let __values: [G; 3] = [__v_1, __v_6, __v_23]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_25: G = { let __values: [G; 3] = [__v_1, __v_5, __v_24]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_26: G = { let __values: [G; 3] = [__v_1, __v_4, __v_25]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_1, __v_3, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_1, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_179] = [__v_28]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_180: usize = 2; const IN_180: usize = 2; const OUT_180: usize = 1; -fn aiur_fn_180(inp: [G; IN_180], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_180] = [__v_1]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_13]; record.function_queries[180].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_180(inp: [G; IN_180], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_180] = [__v_1]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_13]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_181: usize = 2; const IN_181: usize = 2; const OUT_181: usize = 1; -fn aiur_fn_181(inp: [G; IN_181], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_181] = [__v_3]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_181] = [__v_1]; record.function_queries[181].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } +fn aiur_fn_181(inp: [G; IN_181], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_181] = [__v_3]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_181] = [__v_1]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } const INPUT_SIZE_182: usize = 3; const IN_182: usize = 3; const OUT_182: usize = 2; -fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_182] = [__v_0, __v_1]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = (__v_0 * __v_0); let __v_4: G = G::from_u64(7); let __v_5: G = (__v_1 * __v_1); let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_3 + __v_6); let __v_8: G = (__v_0 * __v_1); let __v_9: G = (__v_1 * __v_0); let __v_10: G = (__v_8 + __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 - __v_11); let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_13, __v_14]; record.function_queries[182].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_182(inp: [G; IN_182], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_182] = [__v_0, __v_1]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = __v_0 * __v_0; let __v_4: G = G::from_u64(7); let __v_5: G = __v_1 * __v_1; let __v_6: G = __v_4 * __v_5; let __v_7: G = __v_3 + __v_6; let __v_8: G = __v_0 * __v_1; let __v_9: G = __v_1 * __v_0; let __v_10: G = __v_8 + __v_9; let __v_11: G = G::from_u64(1); let __v_12: G = __v_2 - __v_11; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_13, __v_14]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_183: usize = 1; const IN_183: usize = 1; const OUT_183: usize = 1; -fn aiur_fn_183(inp: [G; IN_183], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 + __v_1); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); let __ret: [G; OUT_183] = [__v_4]; record.function_queries[183].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_183(inp: [G; IN_183], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_183] = [__v_1]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = __v_0 + __v_1; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __v_3 * __v_3; let __ret: [G; OUT_183] = [__v_4]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_184: usize = 3; const IN_184: usize = 3; const OUT_184: usize = 2; -fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); let __ret: [G; OUT_184] = [__v_7, __v_8]; record.function_queries[184].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_184(inp: [G; IN_184], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = __v_3 - __v_5; let __v_8: G = __v_4 - __v_6; let __ret: [G; OUT_184] = [__v_7, __v_8]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_185: usize = 1; const IN_185: usize = 1; const OUT_185: usize = 1; -fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = (__v_0 - __v_2); let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_185] = [__v_5]; record.function_queries[185].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_185(inp: [G; IN_185], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_1]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = __v_0 - __v_2; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_1 * __v_4; let __ret: [G; OUT_185] = [__v_5]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_186: usize = 3; const IN_186: usize = 3; const OUT_186: usize = 8; -fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = aiur::execute::g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_11 - __v_5); let __v_13: G = (__v_9 * __v_12); if (__v_13 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_14: G = (__v_10 * __v_12); if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_15: G = (__v_0 - __v_5); let __v_16: G = (__v_1 - __v_6); let __v_17: G = (__v_15 * __v_15); let __v_18: G = G::from_u64(7); let __v_19: G = (__v_16 * __v_16); let __v_20: G = (__v_18 * __v_19); let __v_21: G = (__v_17 - __v_20); let __v_22: G = aiur::execute::g_inverse_value(__v_21); let __v_23: G = (__v_21 * __v_22); let __v_24: G = (__v_23 - __v_5); let __v_25: G = (__v_21 * __v_24); if (__v_25 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_26: G = (__v_22 * __v_24); if (__v_26 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_27: G = (__v_15 * __v_22); let __v_28: G = (__v_6 - __v_16); let __v_29: G = (__v_28 * __v_22); let __v_30: G = (__v_7 * __v_27); let __v_31: G = (__v_8 * __v_29); let __v_32: G = (__v_18 * __v_31); let __v_33: G = (__v_30 + __v_32); let __v_34: G = (__v_7 * __v_29); let __v_35: G = (__v_8 * __v_27); let __v_36: G = (__v_34 + __v_35); let __v_37: G = (__v_0 - __v_10); let __v_38: G = (__v_37 * __v_37); let __v_39: G = (__v_38 - __v_20); let __v_40: G = aiur::execute::g_inverse_value(__v_39); let __v_41: G = (__v_39 * __v_40); let __v_42: G = (__v_41 - __v_5); let __v_43: G = (__v_39 * __v_42); if (__v_43 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_44: G = (__v_40 * __v_42); if (__v_44 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_45: G = (__v_37 * __v_40); let __v_46: G = (__v_28 * __v_40); let __v_47: G = (__v_7 * __v_45); let __v_48: G = (__v_8 * __v_46); let __v_49: G = (__v_18 * __v_48); let __v_50: G = (__v_47 + __v_49); let __v_51: G = (__v_7 * __v_46); let __v_52: G = (__v_8 * __v_45); let __v_53: G = (__v_51 + __v_52); let __v_54: G = (__v_7 * __v_7); let __v_55: G = (__v_8 * __v_8); let __v_56: G = (__v_18 * __v_55); let __v_57: G = (__v_54 - __v_56); let __v_58: G = aiur::execute::g_inverse_value(__v_57); let __v_59: G = (__v_57 * __v_58); let __v_60: G = (__v_59 - __v_5); let __v_61: G = (__v_57 * __v_60); if (__v_61 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_62: G = (__v_58 * __v_60); if (__v_62 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_63: G = (__v_7 * __v_58); let __v_64: G = (__v_6 - __v_8); let __v_65: G = (__v_64 * __v_58); let __ret: [G; OUT_186] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[186].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_186(inp: [G; IN_186], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = __v_3 - __v_5; let __v_8: G = __v_4 - __v_6; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = aiur::execute::g_inverse_value(__v_9); let __v_11: G = __v_9 * __v_10; let __v_12: G = __v_11 - __v_5; let __v_13: G = __v_9 * __v_12; if (__v_13 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_14: G = __v_10 * __v_12; if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_15: G = __v_0 - __v_5; let __v_16: G = __v_1 - __v_6; let __v_17: G = __v_15 * __v_15; let __v_18: G = G::from_u64(7); let __v_19: G = __v_16 * __v_16; let __v_20: G = __v_18 * __v_19; let __v_21: G = __v_17 - __v_20; let __v_22: G = aiur::execute::g_inverse_value(__v_21); let __v_23: G = __v_21 * __v_22; let __v_24: G = __v_23 - __v_5; let __v_25: G = __v_21 * __v_24; if (__v_25 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_26: G = __v_22 * __v_24; if (__v_26 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_27: G = __v_15 * __v_22; let __v_28: G = __v_6 - __v_16; let __v_29: G = __v_28 * __v_22; let __v_30: G = __v_7 * __v_27; let __v_31: G = __v_8 * __v_29; let __v_32: G = __v_18 * __v_31; let __v_33: G = __v_30 + __v_32; let __v_34: G = __v_7 * __v_29; let __v_35: G = __v_8 * __v_27; let __v_36: G = __v_34 + __v_35; let __v_37: G = __v_0 - __v_10; let __v_38: G = __v_37 * __v_37; let __v_39: G = __v_38 - __v_20; let __v_40: G = aiur::execute::g_inverse_value(__v_39); let __v_41: G = __v_39 * __v_40; let __v_42: G = __v_41 - __v_5; let __v_43: G = __v_39 * __v_42; if (__v_43 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_44: G = __v_40 * __v_42; if (__v_44 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_45: G = __v_37 * __v_40; let __v_46: G = __v_28 * __v_40; let __v_47: G = __v_7 * __v_45; let __v_48: G = __v_8 * __v_46; let __v_49: G = __v_18 * __v_48; let __v_50: G = __v_47 + __v_49; let __v_51: G = __v_7 * __v_46; let __v_52: G = __v_8 * __v_45; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_7 * __v_7; let __v_55: G = __v_8 * __v_8; let __v_56: G = __v_18 * __v_55; let __v_57: G = __v_54 - __v_56; let __v_58: G = aiur::execute::g_inverse_value(__v_57); let __v_59: G = __v_57 * __v_58; let __v_60: G = __v_59 - __v_5; let __v_61: G = __v_57 * __v_60; if (__v_61 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_62: G = __v_58 * __v_60; if (__v_62 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __v_63: G = __v_7 * __v_58; let __v_64: G = __v_6 - __v_8; let __v_65: G = __v_64 * __v_58; let __ret: [G; OUT_186] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_187: usize = 6; const IN_187: usize = 6; const OUT_187: usize = 2; -fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = (__v_0 * __v_2); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_1 * __v_3); let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_0 * __v_3); let __v_12: G = (__v_1 * __v_2); let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_10 + __v_4); let __v_15: G = (__v_13 + __v_5); let __ret: [G; OUT_187] = [__v_14, __v_15]; record.function_queries[187].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_187(inp: [G; IN_187], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = __v_0 * __v_2; let __v_7: G = G::from_u64(7); let __v_8: G = __v_1 * __v_3; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_0 * __v_3; let __v_12: G = __v_1 * __v_2; let __v_13: G = __v_11 + __v_12; let __v_14: G = __v_10 + __v_4; let __v_15: G = __v_13 + __v_5; let __ret: [G; OUT_187] = [__v_14, __v_15]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_188: usize = 4; const IN_188: usize = 4; const OUT_188: usize = 2; -fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 * __v_4); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_3 * __v_5); let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 + __v_9); let __v_11: G = (__v_2 * __v_5); let __v_12: G = (__v_3 * __v_4); let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_0 + __v_10); let __v_15: G = (__v_1 + __v_13); let __ret: [G; OUT_188] = [__v_14, __v_15]; record.function_queries[188].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_188(inp: [G; IN_188], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = __v_2 * __v_4; let __v_7: G = G::from_u64(7); let __v_8: G = __v_3 * __v_5; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = __v_2 * __v_5; let __v_12: G = __v_3 * __v_4; let __v_13: G = __v_11 + __v_12; let __v_14: G = __v_0 + __v_10; let __v_15: G = __v_1 + __v_13; let __ret: [G; OUT_188] = [__v_14, __v_15]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_189: usize = 1; const IN_189: usize = 1; const OUT_189: usize = 1; -fn aiur_fn_189(inp: [G; IN_189], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_6]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, (&__args[..]))?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { (*(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188])) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, (&__args[..]))?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { (*(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189])) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_13]; record.function_queries[189].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_189(inp: [G; IN_189], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_6]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(188, &__args[..])?) { [G::ZERO; OUT_188] } else { let (__hash, __hit) = record.function_queries[188].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[188].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => { aiur_fn_188::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, &__args[..])?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_189] = [__v_13]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_190: usize = 15; const IN_190: usize = 15; const OUT_190: usize = 2; -fn aiur_fn_190(inp: [G; IN_190], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(248, (&__args[..]))?) { [G::ZERO; OUT_248] } else { let (__hash, __hit) = record.function_queries[248].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[248].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { (*(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248])) }; __ret }, _ => { aiur_fn_248::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_190] = [__v_16, __v_19]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = (__v_16 + __v_17); let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_5, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_19, __v_20]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_190] = [__v_9, __v_10]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_190] = [__v_11, __v_12]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_190] = [__v_13, __v_14]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 + __v_21); let __v_24: G = (__v_20 + __v_22); let __ret: [G; OUT_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 - __v_21); let __v_24: G = (__v_20 - __v_22); let __ret: [G; OUT_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 * __v_21); let __v_24: G = G::from_u64(7); let __v_25: G = (__v_20 * __v_22); let __v_26: G = (__v_24 * __v_25); let __v_27: G = (__v_23 + __v_26); let __v_28: G = (__v_19 * __v_22); let __v_29: G = (__v_20 * __v_21); let __v_30: G = (__v_28 + __v_29); let __ret: [G; OUT_190] = [__v_27, __v_30]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); let __v_22: G = (__v_21 - __v_19); let __v_23: G = (__v_21 - __v_20); let __ret: [G; OUT_190] = [__v_22, __v_23]; record.function_queries[190].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } +fn aiur_fn_190(inp: [G; IN_190], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(248, &__args[..])?) { [G::ZERO; OUT_248] } else { let (__hash, __hit) = record.function_queries[248].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[248].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => { aiur_fn_248::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_190] = [__v_16, __v_19]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = __v_16 + __v_17; let __v_20: G = __v_16 + __v_19; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_5, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_21, __v_22]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_19, __v_20]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_190] = [__v_9, __v_10]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_190] = [__v_11, __v_12]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_190] = [__v_13, __v_14]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_19 + __v_21; let __v_24: G = __v_20 + __v_22; let __ret: [G; OUT_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_19 - __v_21; let __v_24: G = __v_20 - __v_22; let __ret: [G; OUT_190] = [__v_23, __v_24]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_19 * __v_21; let __v_24: G = G::from_u64(7); let __v_25: G = __v_20 * __v_22; let __v_26: G = __v_24 * __v_25; let __v_27: G = __v_23 + __v_26; let __v_28: G = __v_19 * __v_22; let __v_29: G = __v_20 * __v_21; let __v_30: G = __v_28 + __v_29; let __ret: [G; OUT_190] = [__v_27, __v_30]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); let __v_22: G = __v_21 - __v_19; let __v_23: G = __v_21 - __v_20; let __ret: [G; OUT_190] = [__v_22, __v_23]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } const INPUT_SIZE_191: usize = 19; const IN_191: usize = 19; const OUT_191: usize = 2; -fn aiur_fn_191(inp: [G; IN_191], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_191] = [__v_0, __v_1]; record.function_queries[191].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_26, __v_27]; record.function_queries[191].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } +fn aiur_fn_191(inp: [G; IN_191], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_191] = [__v_0, __v_1]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_26, __v_27]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } const INPUT_SIZE_192: usize = 8; const IN_192: usize = 8; const OUT_192: usize = 4; -fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = (__v_0 * __v_4); let __v_9: G = G::from_u64(7); let __v_10: G = (__v_1 * __v_5); let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_8 + __v_11); let __v_13: G = (__v_0 * __v_5); let __v_14: G = (__v_1 * __v_4); let __v_15: G = (__v_13 + __v_14); let __v_16: G = G::from_u64(0); let __v_17: G = (__v_2 * __v_6); let __v_18: G = (__v_3 * __v_7); let __v_19: G = (__v_9 * __v_18); let __v_20: G = (__v_17 + __v_19); let __v_21: G = (__v_2 * __v_7); let __v_22: G = (__v_3 * __v_6); let __v_23: G = (__v_21 + __v_22); let __v_24: G = (__v_9 * __v_20); let __v_25: G = (__v_16 * __v_23); let __v_26: G = (__v_9 * __v_25); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_9 * __v_23); let __v_29: G = (__v_16 * __v_20); let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_12 + __v_27); let __v_32: G = (__v_15 + __v_30); let __v_33: G = (__v_0 * __v_6); let __v_34: G = (__v_1 * __v_7); let __v_35: G = (__v_9 * __v_34); let __v_36: G = (__v_33 + __v_35); let __v_37: G = (__v_0 * __v_7); let __v_38: G = (__v_1 * __v_6); let __v_39: G = (__v_37 + __v_38); let __v_40: G = (__v_2 * __v_4); let __v_41: G = (__v_3 * __v_5); let __v_42: G = (__v_9 * __v_41); let __v_43: G = (__v_40 + __v_42); let __v_44: G = (__v_2 * __v_5); let __v_45: G = (__v_3 * __v_4); let __v_46: G = (__v_44 + __v_45); let __v_47: G = (__v_36 + __v_43); let __v_48: G = (__v_39 + __v_46); let __ret: [G; OUT_192] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[192].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_192(inp: [G; IN_192], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = __v_0 * __v_4; let __v_9: G = G::from_u64(7); let __v_10: G = __v_1 * __v_5; let __v_11: G = __v_9 * __v_10; let __v_12: G = __v_8 + __v_11; let __v_13: G = __v_0 * __v_5; let __v_14: G = __v_1 * __v_4; let __v_15: G = __v_13 + __v_14; let __v_16: G = G::from_u64(0); let __v_17: G = __v_2 * __v_6; let __v_18: G = __v_3 * __v_7; let __v_19: G = __v_9 * __v_18; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_2 * __v_7; let __v_22: G = __v_3 * __v_6; let __v_23: G = __v_21 + __v_22; let __v_24: G = __v_9 * __v_20; let __v_25: G = __v_16 * __v_23; let __v_26: G = __v_9 * __v_25; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_9 * __v_23; let __v_29: G = __v_16 * __v_20; let __v_30: G = __v_28 + __v_29; let __v_31: G = __v_12 + __v_27; let __v_32: G = __v_15 + __v_30; let __v_33: G = __v_0 * __v_6; let __v_34: G = __v_1 * __v_7; let __v_35: G = __v_9 * __v_34; let __v_36: G = __v_33 + __v_35; let __v_37: G = __v_0 * __v_7; let __v_38: G = __v_1 * __v_6; let __v_39: G = __v_37 + __v_38; let __v_40: G = __v_2 * __v_4; let __v_41: G = __v_3 * __v_5; let __v_42: G = __v_9 * __v_41; let __v_43: G = __v_40 + __v_42; let __v_44: G = __v_2 * __v_5; let __v_45: G = __v_3 * __v_4; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_36 + __v_43; let __v_48: G = __v_39 + __v_46; let __ret: [G; OUT_192] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_193: usize = 19; const IN_193: usize = 19; const OUT_193: usize = 4; -fn aiur_fn_193(inp: [G; IN_193], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = (__v_26 + __v_30); let __v_33: G = (__v_27 + __v_31); let __ret: [G; OUT_193] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[193].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } +fn aiur_fn_193(inp: [G; IN_193], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __v_26 + __v_30; let __v_33: G = __v_27 + __v_31; let __ret: [G; OUT_193] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } const INPUT_SIZE_194: usize = 44; const IN_194: usize = 44; const OUT_194: usize = 2; -fn aiur_fn_194(inp: [G; IN_194], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, (&__args[..]))?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { (*(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193])) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = __r_arr[3]; let __v_52: G = (__v_48 + __v_22); let __v_53: G = (__v_49 + __v_23); let __v_54: G = (__v_50 + __v_24); let __v_55: G = (__v_51 + __v_25); let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, (&__args[..]))?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { (*(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190])) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = (__v_56 * __v_10); let __v_63: G = G::from_u64(7); let __v_64: G = (__v_57 * __v_11); let __v_65: G = (__v_63 * __v_64); let __v_66: G = (__v_62 + __v_65); let __v_67: G = (__v_56 * __v_11); let __v_68: G = (__v_57 * __v_10); let __v_69: G = (__v_67 + __v_68); let __v_70: G = (__v_58 + __v_66); let __v_71: G = (__v_59 + __v_69); let __v_72: G = (__v_56 * __v_12); let __v_73: G = (__v_57 * __v_13); let __v_74: G = (__v_63 * __v_73); let __v_75: G = (__v_72 + __v_74); let __v_76: G = (__v_56 * __v_13); let __v_77: G = (__v_57 * __v_12); let __v_78: G = (__v_76 + __v_77); let __v_79: G = (__v_60 + __v_75); let __v_80: G = (__v_61 + __v_78); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = G::from_u64(1); let __v_86: G = (__v_85 - __v_6); let __v_87: G = (__v_5 + __v_86); match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = (__v_7 + __v_7); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_88]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = __r_arr[1]; let __v_91: G = G::from_u64(1); let __v_92: G = (__v_7 + __v_91); let __v_93: G = (__v_7 + __v_92); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = (__v_97 + __v_18); let __v_100: G = (__v_98 + __v_19); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_91]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = (__v_101 + __v_20); let __v_104: G = (__v_102 + __v_21); let __v_105: G = (__v_99 - __v_89); let __v_106: G = (__v_100 - __v_90); let __v_107: G = (__v_103 - __v_94); let __v_108: G = (__v_104 - __v_95); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; let __v_111: G = __r_arr[2]; let __v_112: G = __r_arr[3]; let __v_113: G = (__v_109 - __v_70); let __v_114: G = (__v_110 - __v_71); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = (__v_111 - __v_79); let __v_118: G = (__v_112 - __v_80); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_119, __v_120]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_88: G = G::from_u64(1); let __v_89: G = (__v_8 - __v_88); match __v_89.as_canonical_u64() { 0u64 => { let __v_90: G = (__v_7 + __v_7); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = G::from_u64(1); let __v_94: G = (__v_7 + __v_93); let __v_95: G = (__v_7 + __v_94); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = G::from_u64(2); let __v_99: G = (__v_7 + __v_98); let __v_100: G = (__v_7 + __v_99); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = G::from_u64(3); let __v_104: G = (__v_7 + __v_103); let __v_105: G = (__v_7 + __v_104); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = (__v_101 - __v_91); let __v_109: G = (__v_102 - __v_92); let __v_110: G = (__v_106 - __v_96); let __v_111: G = (__v_107 - __v_97); let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, (&__args[..]))?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { (*(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192])) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = __r_arr[2]; let __v_115: G = __r_arr[3]; let __v_116: G = (__v_112 - __v_70); let __v_117: G = (__v_113 - __v_71); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = (__v_114 - __v_79); let __v_121: G = (__v_115 - __v_80); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = (__v_5 + __v_93); let __v_125: G = G::from_u64(0); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122, __v_123, __v_2, __v_3, __v_47, __v_124, __v_6, __v_94, __v_9, __v_9, __v_93, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_126: G = __r_arr[0]; let __v_127: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_126, __v_127]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_90: G = G::from_u64(1); let __v_91: G = (__v_5 + __v_90); let __v_92: G = (__v_8 - __v_90); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_91, __v_6, __v_7, __v_92, __v_9, __v_81, __v_82, __v_83, __v_84, __v_70, __v_71, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_93, __v_94]; record.function_queries[194].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } +fn aiur_fn_194(inp: [G; IN_194], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(193, &__args[..])?) { [G::ZERO; OUT_193] } else { let (__hash, __hit) = record.function_queries[193].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[193].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => { aiur_fn_193::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = __r_arr[3]; let __v_52: G = __v_48 + __v_22; let __v_53: G = __v_49 + __v_23; let __v_54: G = __v_50 + __v_24; let __v_55: G = __v_51 + __v_25; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(190, &__args[..])?) { [G::ZERO; OUT_190] } else { let (__hash, __hit) = record.function_queries[190].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[190].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => { aiur_fn_190::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __v_56 * __v_10; let __v_63: G = G::from_u64(7); let __v_64: G = __v_57 * __v_11; let __v_65: G = __v_63 * __v_64; let __v_66: G = __v_62 + __v_65; let __v_67: G = __v_56 * __v_11; let __v_68: G = __v_57 * __v_10; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_58 + __v_66; let __v_71: G = __v_59 + __v_69; let __v_72: G = __v_56 * __v_12; let __v_73: G = __v_57 * __v_13; let __v_74: G = __v_63 * __v_73; let __v_75: G = __v_72 + __v_74; let __v_76: G = __v_56 * __v_13; let __v_77: G = __v_57 * __v_12; let __v_78: G = __v_76 + __v_77; let __v_79: G = __v_60 + __v_75; let __v_80: G = __v_61 + __v_78; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = __r_arr[2]; let __v_84: G = __r_arr[3]; let __v_85: G = G::from_u64(1); let __v_86: G = __v_85 - __v_6; let __v_87: G = __v_5 + __v_86; match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = __v_7 + __v_7; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_88]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = __r_arr[1]; let __v_91: G = G::from_u64(1); let __v_92: G = __v_7 + __v_91; let __v_93: G = __v_7 + __v_92; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = __v_97 + __v_18; let __v_100: G = __v_98 + __v_19; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36, __v_91]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = __v_101 + __v_20; let __v_104: G = __v_102 + __v_21; let __v_105: G = __v_99 - __v_89; let __v_106: G = __v_100 - __v_90; let __v_107: G = __v_103 - __v_94; let __v_108: G = __v_104 - __v_95; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; let __v_111: G = __r_arr[2]; let __v_112: G = __r_arr[3]; let __v_113: G = __v_109 - __v_70; let __v_114: G = __v_110 - __v_71; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = __v_111 - __v_79; let __v_118: G = __v_112 - __v_80; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_119, __v_120]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_88: G = G::from_u64(1); let __v_89: G = __v_8 - __v_88; match __v_89.as_canonical_u64() { 0u64 => { let __v_90: G = __v_7 + __v_7; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = G::from_u64(1); let __v_94: G = __v_7 + __v_93; let __v_95: G = __v_7 + __v_94; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = G::from_u64(2); let __v_99: G = __v_7 + __v_98; let __v_100: G = __v_7 + __v_99; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = G::from_u64(3); let __v_104: G = __v_7 + __v_103; let __v_105: G = __v_7 + __v_104; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35, __v_105]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __v_101 - __v_91; let __v_109: G = __v_102 - __v_92; let __v_110: G = __v_106 - __v_96; let __v_111: G = __v_107 - __v_97; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(192, &__args[..])?) { [G::ZERO; OUT_192] } else { let (__hash, __hit) = record.function_queries[192].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[192].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => { aiur_fn_192::(__args, __hash, record, io_buffer)? }, } } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = __r_arr[2]; let __v_115: G = __r_arr[3]; let __v_116: G = __v_112 - __v_70; let __v_117: G = __v_113 - __v_71; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = __v_114 - __v_79; let __v_121: G = __v_115 - __v_80; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __v_5 + __v_93; let __v_125: G = G::from_u64(0); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122, __v_123, __v_2, __v_3, __v_47, __v_124, __v_6, __v_94, __v_9, __v_9, __v_93, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_126: G = __r_arr[0]; let __v_127: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_126, __v_127]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_90: G = G::from_u64(1); let __v_91: G = __v_5 + __v_90; let __v_92: G = __v_8 - __v_90; let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_91, __v_6, __v_7, __v_92, __v_9, __v_81, __v_82, __v_83, __v_84, __v_70, __v_71, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_93, __v_94]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } const INPUT_SIZE_195: usize = 28; const IN_195: usize = 28; const OUT_195: usize = 2; -fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_28, __v_28, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = (__v_17 - __v_15); let __v_32: G = (__v_28 - __v_28); let __v_33: G = (__v_31 * __v_27); let __v_34: G = G::from_u64(7); let __v_35: G = (__v_32 * __v_28); let __v_36: G = (__v_34 * __v_35); let __v_37: G = (__v_33 + __v_36); let __v_38: G = (__v_31 * __v_28); let __v_39: G = (__v_32 * __v_27); let __v_40: G = (__v_38 + __v_39); let __v_41: G = (__v_21 * __v_37); let __v_42: G = (__v_22 * __v_40); let __v_43: G = (__v_34 * __v_42); let __v_44: G = (__v_41 + __v_43); let __v_45: G = (__v_21 * __v_40); let __v_46: G = (__v_22 * __v_37); let __v_47: G = (__v_45 + __v_46); let __v_48: G = (__v_18 - __v_16); let __v_49: G = (__v_48 * __v_27); let __v_50: G = (__v_49 + __v_36); let __v_51: G = (__v_48 * __v_28); let __v_52: G = (__v_51 + __v_39); let __v_53: G = (__v_21 * __v_50); let __v_54: G = (__v_22 * __v_52); let __v_55: G = (__v_34 * __v_54); let __v_56: G = (__v_53 + __v_55); let __v_57: G = (__v_21 * __v_52); let __v_58: G = (__v_22 * __v_50); let __v_59: G = (__v_57 + __v_58); let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; let __v_63: G = __loaded[3]; match __v_60.as_canonical_u64() { 1u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = (__v_65 - __v_67); let __v_70: G = (__v_66 - __v_68); let __v_71: G = (__v_69 + __v_44); let __v_72: G = (__v_70 + __v_47); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __v_79: G = __r_arr[1]; let __v_80: G = (__v_76 - __v_78); let __v_81: G = (__v_77 - __v_79); let __v_82: G = (__v_80 + __v_56); let __v_83: G = (__v_81 + __v_59); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_84, __v_85]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_29, __v_30, __v_25, __v_26, __v_2, __v_64, __v_65, __v_64, __v_3, __v_3, __v_66, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_44, __v_47, __v_56, __v_59, __v_11, __v_28, __v_12, __v_28, __v_13, __v_28, __v_14, __v_28, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_67, __v_68]; record.function_queries[195].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } +fn aiur_fn_195(inp: [G; IN_195], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_28, __v_28, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __v_17 - __v_15; let __v_32: G = __v_28 - __v_28; let __v_33: G = __v_31 * __v_27; let __v_34: G = G::from_u64(7); let __v_35: G = __v_32 * __v_28; let __v_36: G = __v_34 * __v_35; let __v_37: G = __v_33 + __v_36; let __v_38: G = __v_31 * __v_28; let __v_39: G = __v_32 * __v_27; let __v_40: G = __v_38 + __v_39; let __v_41: G = __v_21 * __v_37; let __v_42: G = __v_22 * __v_40; let __v_43: G = __v_34 * __v_42; let __v_44: G = __v_41 + __v_43; let __v_45: G = __v_21 * __v_40; let __v_46: G = __v_22 * __v_37; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_18 - __v_16; let __v_49: G = __v_48 * __v_27; let __v_50: G = __v_49 + __v_36; let __v_51: G = __v_48 * __v_28; let __v_52: G = __v_51 + __v_39; let __v_53: G = __v_21 * __v_50; let __v_54: G = __v_22 * __v_52; let __v_55: G = __v_34 * __v_54; let __v_56: G = __v_53 + __v_55; let __v_57: G = __v_21 * __v_52; let __v_58: G = __v_22 * __v_50; let __v_59: G = __v_57 + __v_58; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; let __v_63: G = __loaded[3]; match __v_60.as_canonical_u64() { 1u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = __v_65 - __v_67; let __v_70: G = __v_66 - __v_68; let __v_71: G = __v_69 + __v_44; let __v_72: G = __v_70 + __v_47; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __v_79: G = __r_arr[1]; let __v_80: G = __v_76 - __v_78; let __v_81: G = __v_77 - __v_79; let __v_82: G = __v_80 + __v_56; let __v_83: G = __v_81 + __v_59; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_84, __v_85]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_29, __v_30, __v_25, __v_26, __v_2, __v_64, __v_65, __v_64, __v_3, __v_3, __v_66, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_44, __v_47, __v_56, __v_59, __v_11, __v_28, __v_12, __v_28, __v_13, __v_28, __v_14, __v_28, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_195] = [__v_67, __v_68]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } const INPUT_SIZE_196: usize = 8; const IN_196: usize = 8; const OUT_196: usize = 1; -fn aiur_fn_196(inp: [G; IN_196], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_5, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_4, __v_8, __v_13]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_2, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_1, __v_8, __v_16]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_0, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_196] = [__v_18]; record.function_queries[196].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_196(inp: [G; IN_196], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_12: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_5, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_4, __v_8, __v_13]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_2, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_1, __v_8, __v_16]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_0, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_196] = [__v_18]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_197: usize = 5; const IN_197: usize = 5; const OUT_197: usize = 2; -fn aiur_fn_197(inp: [G; IN_197], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_197] = [__v_9, __v_9]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = (__v_3 * __v_6); let __v_10: G = G::from_u64(7); let __v_11: G = (__v_4 * __v_7); let __v_12: G = (__v_10 * __v_11); let __v_13: G = (__v_9 + __v_12); let __v_14: G = (__v_3 * __v_7); let __v_15: G = (__v_4 * __v_6); let __v_16: G = (__v_14 + __v_15); let __v_17: G = (__v_3 * __v_1); let __v_18: G = (__v_4 * __v_2); let __v_19: G = (__v_10 * __v_18); let __v_20: G = (__v_17 + __v_19); let __v_21: G = (__v_3 * __v_2); let __v_22: G = (__v_4 * __v_1); let __v_23: G = (__v_21 + __v_22); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = (__v_13 + __v_24); let __v_27: G = (__v_16 + __v_25); let __ret: [G; OUT_197] = [__v_26, __v_27]; record.function_queries[197].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } +fn aiur_fn_197(inp: [G; IN_197], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_197] = [__v_9, __v_9]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = __v_3 * __v_6; let __v_10: G = G::from_u64(7); let __v_11: G = __v_4 * __v_7; let __v_12: G = __v_10 * __v_11; let __v_13: G = __v_9 + __v_12; let __v_14: G = __v_3 * __v_7; let __v_15: G = __v_4 * __v_6; let __v_16: G = __v_14 + __v_15; let __v_17: G = __v_3 * __v_1; let __v_18: G = __v_4 * __v_2; let __v_19: G = __v_10 * __v_18; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_3 * __v_2; let __v_22: G = __v_4 * __v_1; let __v_23: G = __v_21 + __v_22; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __v_13 + __v_24; let __v_27: G = __v_16 + __v_25; let __ret: [G; OUT_197] = [__v_26, __v_27]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } const INPUT_SIZE_198: usize = 1; const IN_198: usize = 1; const OUT_198: usize = 1; -fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_198(inp: [G; IN_198], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_198] = [__v_1]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_199: usize = 4; const IN_199: usize = 4; const OUT_199: usize = 2; -fn aiur_fn_199(inp: [G; IN_199], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { match __v_0.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_6, __v_8]; record.function_queries[199].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_199(inp: [G; IN_199], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_0.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_199] = [__v_5, __v_5]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_6, __v_8]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_200: usize = 20; const IN_200: usize = 20; const OUT_200: usize = 1; -fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; match __v_20.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_31]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(32); let __v_33: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_31), (&__v_32)) } else { aiur::execute::bytes2_less_than_value(__v_31, __v_32, record) }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(198, (&__args[..]))?) { [G::ZERO; OUT_198] } else { let (__hash, __hit) = record.function_queries[198].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[198].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { (*(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198])) }; __ret }, _ => { aiur_fn_198::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_45.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; break '__mc_0 [__v_49, __v_51]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }; let __v_47: G = __mc_out___mc_0[0]; let __v_48: G = __mc_out___mc_0[1]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = (__v_49 - __v_27); let __v_51: G = G::from_bool((__v_50 == G::ZERO)); let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = (__v_53 - __v_27); let __v_55: G = G::from_bool((__v_54 == G::ZERO)); if (__v_55 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_56 - __v_29); let __v_58: G = G::from_bool((__v_57 == G::ZERO)); if (__v_58 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_59 - __v_29); let __v_61: G = G::from_bool((__v_60 == G::ZERO)); if (__v_61 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = (__v_62 - __v_28); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); if (__v_64 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = (__v_65 - __v_28); let __v_67: G = G::from_bool((__v_66 == G::ZERO)); if (__v_67 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); let __v_71: G = (__v_68 - __v_52); let __v_72: G = (__v_69 - __v_70); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = aiur::execute::g_inverse_value(__v_73); let __v_75: G = (__v_73 * __v_74); let __v_76: G = (__v_75 - __v_52); let __v_77: G = (__v_73 * __v_76); if (__v_77 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_78: G = (__v_74 * __v_76); if (__v_78 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_79: G = (__v_18 - __v_52); let __v_80: G = (__v_19 - __v_70); let __v_81: G = (__v_79 * __v_79); let __v_82: G = G::from_u64(7); let __v_83: G = (__v_80 * __v_80); let __v_84: G = (__v_82 * __v_83); let __v_85: G = (__v_81 - __v_84); let __v_86: G = aiur::execute::g_inverse_value(__v_85); let __v_87: G = (__v_85 * __v_86); let __v_88: G = (__v_87 - __v_52); let __v_89: G = (__v_85 * __v_88); if (__v_89 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_90: G = (__v_86 * __v_88); if (__v_90 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_91: G = (__v_79 * __v_86); let __v_92: G = (__v_70 - __v_80); let __v_93: G = (__v_92 * __v_86); let __v_94: G = (__v_71 * __v_91); let __v_95: G = (__v_72 * __v_93); let __v_96: G = (__v_82 * __v_95); let __v_97: G = (__v_94 + __v_96); let __v_98: G = (__v_71 * __v_93); let __v_99: G = (__v_72 * __v_91); let __v_100: G = (__v_98 + __v_99); let __v_101: G = (__v_18 - __v_74); let __v_102: G = (__v_101 * __v_101); let __v_103: G = (__v_102 - __v_84); let __v_104: G = aiur::execute::g_inverse_value(__v_103); let __v_105: G = (__v_103 * __v_104); let __v_106: G = (__v_105 - __v_52); let __v_107: G = (__v_103 * __v_106); if (__v_107 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_108: G = (__v_104 * __v_106); if (__v_108 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_109: G = (__v_101 * __v_104); let __v_110: G = (__v_92 * __v_104); let __v_111: G = (__v_71 * __v_109); let __v_112: G = (__v_72 * __v_110); let __v_113: G = (__v_82 * __v_112); let __v_114: G = (__v_111 + __v_113); let __v_115: G = (__v_71 * __v_110); let __v_116: G = (__v_72 * __v_109); let __v_117: G = (__v_115 + __v_116); let __v_118: G = (__v_71 * __v_71); let __v_119: G = (__v_72 * __v_72); let __v_120: G = (__v_82 * __v_119); let __v_121: G = (__v_118 - __v_120); let __v_122: G = aiur::execute::g_inverse_value(__v_121); let __v_123: G = (__v_121 * __v_122); let __v_124: G = (__v_123 - __v_52); let __v_125: G = (__v_121 * __v_124); if (__v_125 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_122 * __v_124); if (__v_126 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_127: G = (__v_71 * __v_122); let __v_128: G = (__v_70 - __v_72); let __v_129: G = (__v_128 * __v_122); let __v_130: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_131: G = { let __values: [G; 4] = [__v_70, __v_37, __v_70, __v_130]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_132: G = { let __values: [G; 4] = [__v_70, __v_36, __v_70, __v_131]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_133: G = { let __values: [G; 4] = [__v_70, __v_11, __v_70, __v_132]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_134: G = { let __values: [G; 4] = [__v_70, __v_10, __v_70, __v_133]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_135: G = { let __values: [G; 4] = [__v_70, __v_15, __v_70, __v_134]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_136: G = { let __values: [G; 4] = [__v_70, __v_14, __v_70, __v_135]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_137: G = { let __values: [G; 4] = [__v_70, __v_13, __v_70, __v_136]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_138: G = { let __values: [G; 4] = [__v_70, __v_12, __v_70, __v_137]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, (&__args[..]))?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { (*(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185])) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, (&__args[..]))?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { (*(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183])) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_140: G = __r_arr[0]; let __v_141: G = (__v_139 * __v_140); let __v_142: G = aiur::execute::g_inverse_value(__v_141); let __v_143: G = (__v_141 * __v_142); let __v_144: G = (__v_143 - __v_52); let __v_145: G = (__v_141 * __v_144); if (__v_145 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_146: G = (__v_142 * __v_144); if (__v_146 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_70, __v_70, __v_16, __v_17, __v_23, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, (&__args[..]))?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { (*(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191])) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; let __v_149: G = (__v_36 - __v_10); let __v_150: G = (__v_70 - __v_70); let __v_151: G = (__v_149 * __v_142); let __v_152: G = (__v_150 * __v_70); let __v_153: G = (__v_82 * __v_152); let __v_154: G = (__v_151 + __v_153); let __v_155: G = (__v_149 * __v_70); let __v_156: G = (__v_150 * __v_142); let __v_157: G = (__v_155 + __v_156); let __v_158: G = (__v_114 * __v_154); let __v_159: G = (__v_117 * __v_157); let __v_160: G = (__v_82 * __v_159); let __v_161: G = (__v_158 + __v_160); let __v_162: G = (__v_114 * __v_157); let __v_163: G = (__v_117 * __v_154); let __v_164: G = (__v_162 + __v_163); let __v_165: G = (__v_37 - __v_11); let __v_166: G = (__v_165 * __v_142); let __v_167: G = (__v_166 + __v_153); let __v_168: G = (__v_165 * __v_70); let __v_169: G = (__v_168 + __v_156); let __v_170: G = (__v_114 * __v_167); let __v_171: G = (__v_117 * __v_169); let __v_172: G = (__v_82 * __v_171); let __v_173: G = (__v_170 + __v_172); let __v_174: G = (__v_114 * __v_169); let __v_175: G = (__v_117 * __v_167); let __v_176: G = (__v_174 + __v_175); let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_177: G = __loaded[0]; let __v_178: G = __loaded[1]; let __v_179: G = __loaded[2]; let __v_180: G = __loaded[3]; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_177.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; let __v_186: G = (__v_182 - __v_184); let __v_187: G = (__v_183 - __v_185); let __v_188: G = (__v_186 + __v_161); let __v_189: G = (__v_187 + __v_164); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_190: G = __r_arr[0]; let __v_191: G = __r_arr[1]; let __v_192: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, (&__args[..]))?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { (*(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250])) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = (__v_193 - __v_195); let __v_198: G = (__v_194 - __v_196); let __v_199: G = (__v_197 + __v_173); let __v_200: G = (__v_198 + __v_176); let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, (&__args[..]))?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { (*(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187])) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; break '__mc_1 [__v_201, __v_202]; }, 0u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_147, __v_148, __v_16, __v_17, __v_25, __v_181, __v_182, __v_181, __v_26, __v_26, __v_183, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_161, __v_164, __v_173, __v_176, __v_12, __v_70, __v_13, __v_70, __v_14, __v_70, __v_15, __v_70, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, (&__args[..]))?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { (*(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194])) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; break '__mc_1 [__v_184, __v_185]; }, _ => { return Err(ExecError::MatchNoCase(__v_177.as_canonical_u64())); }, } }; let __v_181: G = __mc_out___mc_1[0]; let __v_182: G = __mc_out___mc_1[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_183, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, (&__args[..]))?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { (*(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239])) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, (&__args[..]))?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { (*(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189])) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_186]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = (__v_187 - __v_35); let __v_189: G = G::from_bool((__v_188 == G::ZERO)); let __v_190: G = G::from_u64(1); if (__v_189 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, (&__args[..]))?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { (*(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182])) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_186, __v_191, __v_192, __v_190, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, (&__args[..]))?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { (*(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197])) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __v_195: G = (__v_181 * __v_127); let __v_196: G = G::from_u64(7); let __v_197: G = (__v_182 * __v_129); let __v_198: G = (__v_196 * __v_197); let __v_199: G = (__v_195 + __v_198); let __v_200: G = (__v_181 * __v_129); let __v_201: G = (__v_182 * __v_127); let __v_202: G = (__v_200 + __v_201); let __v_203: G = (__v_199 - __v_193); let __v_204: G = G::from_bool((__v_203 == G::ZERO)); let __v_205: G = (__v_202 - __v_194); let __v_206: G = G::from_bool((__v_205 == G::ZERO)); let __v_207: G = (__v_204 * __v_206); if (__v_207 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __v_208: G = (__v_9 + __v_190); let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_30, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_208, __v_36, __v_37, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_209]; record.function_queries[200].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } +fn aiur_fn_200(inp: [G; IN_200], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; match __v_20.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_31]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(32); let __v_33: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_31, &__v_32) } else { aiur::execute::bytes2_less_than_value(__v_31, __v_32, record) }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(198, &__args[..])?) { [G::ZERO; OUT_198] } else { let (__hash, __hit) = record.function_queries[198].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[198].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => { aiur_fn_198::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_38, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_42, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_45.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_48, __v_48]; }, 1u64 => { let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_47, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; break '__mc_0 [__v_49, __v_51]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }; let __v_47: G = __mc_out___mc_0[0]; let __v_48: G = __mc_out___mc_0[1]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __v_49 - __v_27; let __v_51: G = G::from_bool(__v_50 == G::ZERO); let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __v_53 - __v_27; let __v_55: G = G::from_bool(__v_54 == G::ZERO); if (__v_55 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __v_56 - __v_29; let __v_58: G = G::from_bool(__v_57 == G::ZERO); if (__v_58 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __v_59 - __v_29; let __v_61: G = G::from_bool(__v_60 == G::ZERO); if (__v_61 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = __v_62 - __v_28; let __v_64: G = G::from_bool(__v_63 == G::ZERO); if (__v_64 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __v_65 - __v_28; let __v_67: G = G::from_bool(__v_66 == G::ZERO); if (__v_67 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); let __v_71: G = __v_68 - __v_52; let __v_72: G = __v_69 - __v_70; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = aiur::execute::g_inverse_value(__v_73); let __v_75: G = __v_73 * __v_74; let __v_76: G = __v_75 - __v_52; let __v_77: G = __v_73 * __v_76; if (__v_77 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_78: G = __v_74 * __v_76; if (__v_78 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_79: G = __v_18 - __v_52; let __v_80: G = __v_19 - __v_70; let __v_81: G = __v_79 * __v_79; let __v_82: G = G::from_u64(7); let __v_83: G = __v_80 * __v_80; let __v_84: G = __v_82 * __v_83; let __v_85: G = __v_81 - __v_84; let __v_86: G = aiur::execute::g_inverse_value(__v_85); let __v_87: G = __v_85 * __v_86; let __v_88: G = __v_87 - __v_52; let __v_89: G = __v_85 * __v_88; if (__v_89 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_90: G = __v_86 * __v_88; if (__v_90 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_91: G = __v_79 * __v_86; let __v_92: G = __v_70 - __v_80; let __v_93: G = __v_92 * __v_86; let __v_94: G = __v_71 * __v_91; let __v_95: G = __v_72 * __v_93; let __v_96: G = __v_82 * __v_95; let __v_97: G = __v_94 + __v_96; let __v_98: G = __v_71 * __v_93; let __v_99: G = __v_72 * __v_91; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_18 - __v_74; let __v_102: G = __v_101 * __v_101; let __v_103: G = __v_102 - __v_84; let __v_104: G = aiur::execute::g_inverse_value(__v_103); let __v_105: G = __v_103 * __v_104; let __v_106: G = __v_105 - __v_52; let __v_107: G = __v_103 * __v_106; if (__v_107 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_108: G = __v_104 * __v_106; if (__v_108 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_109: G = __v_101 * __v_104; let __v_110: G = __v_92 * __v_104; let __v_111: G = __v_71 * __v_109; let __v_112: G = __v_72 * __v_110; let __v_113: G = __v_82 * __v_112; let __v_114: G = __v_111 + __v_113; let __v_115: G = __v_71 * __v_110; let __v_116: G = __v_72 * __v_109; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_71 * __v_71; let __v_119: G = __v_72 * __v_72; let __v_120: G = __v_82 * __v_119; let __v_121: G = __v_118 - __v_120; let __v_122: G = aiur::execute::g_inverse_value(__v_121); let __v_123: G = __v_121 * __v_122; let __v_124: G = __v_123 - __v_52; let __v_125: G = __v_121 * __v_124; if (__v_125 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_126: G = __v_122 * __v_124; if (__v_126 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_127: G = __v_71 * __v_122; let __v_128: G = __v_70 - __v_72; let __v_129: G = __v_128 * __v_122; let __v_130: G = { let __values: [G; 4] = [__v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_131: G = { let __values: [G; 4] = [__v_70, __v_37, __v_70, __v_130]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_132: G = { let __values: [G; 4] = [__v_70, __v_36, __v_70, __v_131]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_133: G = { let __values: [G; 4] = [__v_70, __v_11, __v_70, __v_132]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_134: G = { let __values: [G; 4] = [__v_70, __v_10, __v_70, __v_133]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_135: G = { let __values: [G; 4] = [__v_70, __v_15, __v_70, __v_134]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_136: G = { let __values: [G; 4] = [__v_70, __v_14, __v_70, __v_135]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_137: G = { let __values: [G; 4] = [__v_70, __v_13, __v_70, __v_136]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_138: G = { let __values: [G; 4] = [__v_70, __v_12, __v_70, __v_137]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(185, &__args[..])?) { [G::ZERO; OUT_185] } else { let (__hash, __hit) = record.function_queries[185].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[185].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => { aiur_fn_185::(__args, __hash, record, io_buffer)? }, } } }; let __v_139: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(183, &__args[..])?) { [G::ZERO; OUT_183] } else { let (__hash, __hit) = record.function_queries[183].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[183].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => { aiur_fn_183::(__args, __hash, record, io_buffer)? }, } } }; let __v_140: G = __r_arr[0]; let __v_141: G = __v_139 * __v_140; let __v_142: G = aiur::execute::g_inverse_value(__v_141); let __v_143: G = __v_141 * __v_142; let __v_144: G = __v_143 - __v_52; let __v_145: G = __v_141 * __v_144; if (__v_145 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __v_146: G = __v_142 * __v_144; if (__v_146 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_70, __v_70, __v_16, __v_17, __v_23, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(191, &__args[..])?) { [G::ZERO; OUT_191] } else { let (__hash, __hit) = record.function_queries[191].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[191].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => { aiur_fn_191::(__args, __hash, record, io_buffer)? }, } } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; let __v_149: G = __v_36 - __v_10; let __v_150: G = __v_70 - __v_70; let __v_151: G = __v_149 * __v_142; let __v_152: G = __v_150 * __v_70; let __v_153: G = __v_82 * __v_152; let __v_154: G = __v_151 + __v_153; let __v_155: G = __v_149 * __v_70; let __v_156: G = __v_150 * __v_142; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_114 * __v_154; let __v_159: G = __v_117 * __v_157; let __v_160: G = __v_82 * __v_159; let __v_161: G = __v_158 + __v_160; let __v_162: G = __v_114 * __v_157; let __v_163: G = __v_117 * __v_154; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_37 - __v_11; let __v_166: G = __v_165 * __v_142; let __v_167: G = __v_166 + __v_153; let __v_168: G = __v_165 * __v_70; let __v_169: G = __v_168 + __v_156; let __v_170: G = __v_114 * __v_167; let __v_171: G = __v_117 * __v_169; let __v_172: G = __v_82 * __v_171; let __v_173: G = __v_170 + __v_172; let __v_174: G = __v_114 * __v_169; let __v_175: G = __v_117 * __v_167; let __v_176: G = __v_174 + __v_175; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_177: G = __loaded[0]; let __v_178: G = __loaded[1]; let __v_179: G = __loaded[2]; let __v_180: G = __loaded[3]; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_177.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; let __v_186: G = __v_182 - __v_184; let __v_187: G = __v_183 - __v_185; let __v_188: G = __v_186 + __v_161; let __v_189: G = __v_187 + __v_164; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_190: G = __r_arr[0]; let __v_191: G = __r_arr[1]; let __v_192: G = G::from_u64(1); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_44, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_43, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(250, &__args[..])?) { [G::ZERO; OUT_250] } else { let (__hash, __hit) = record.function_queries[250].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[250].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => { aiur_fn_250::(__args, __hash, record, io_buffer)? }, } } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = __v_193 - __v_195; let __v_198: G = __v_194 - __v_196; let __v_199: G = __v_197 + __v_173; let __v_200: G = __v_198 + __v_176; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(187, &__args[..])?) { [G::ZERO; OUT_187] } else { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[187].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => { aiur_fn_187::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; break '__mc_1 [__v_201, __v_202]; }, 0u64 => { let __v_181: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_147, __v_148, __v_16, __v_17, __v_25, __v_181, __v_182, __v_181, __v_26, __v_26, __v_183, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_181, __v_161, __v_164, __v_173, __v_176, __v_12, __v_70, __v_13, __v_70, __v_14, __v_70, __v_15, __v_70, __v_21, __v_40, __v_41, __v_47, __v_48, __v_43, __v_44, __v_138, __v_97, __v_100, __v_114, __v_117, __v_101, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(194, &__args[..])?) { [G::ZERO; OUT_194] } else { let (__hash, __hit) = record.function_queries[194].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[194].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => { aiur_fn_194::(__args, __hash, record, io_buffer)? }, } } }; let __v_184: G = __r_arr[0]; let __v_185: G = __r_arr[1]; break '__mc_1 [__v_184, __v_185]; }, _ => { return Err(ExecError::MatchNoCase(__v_177.as_canonical_u64())); }, } }; let __v_181: G = __mc_out___mc_1[0]; let __v_182: G = __mc_out___mc_1[1]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_183, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(239, &__args[..])?) { [G::ZERO; OUT_239] } else { let (__hash, __hit) = record.function_queries[239].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[239].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => { aiur_fn_239::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(189, &__args[..])?) { [G::ZERO; OUT_189] } else { let (__hash, __hit) = record.function_queries[189].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[189].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => { aiur_fn_189::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_186]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_187: G = __r_arr[0]; let __v_188: G = __v_187 - __v_35; let __v_189: G = G::from_bool(__v_188 == G::ZERO); let __v_190: G = G::from_u64(1); if (__v_189 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_18, __v_19, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(182, &__args[..])?) { [G::ZERO; OUT_182] } else { let (__hash, __hit) = record.function_queries[182].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[182].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => { aiur_fn_182::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_186, __v_191, __v_192, __v_190, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(197, &__args[..])?) { [G::ZERO; OUT_197] } else { let (__hash, __hit) = record.function_queries[197].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[197].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => { aiur_fn_197::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __v_195: G = __v_181 * __v_127; let __v_196: G = G::from_u64(7); let __v_197: G = __v_182 * __v_129; let __v_198: G = __v_196 * __v_197; let __v_199: G = __v_195 + __v_198; let __v_200: G = __v_181 * __v_129; let __v_201: G = __v_182 * __v_127; let __v_202: G = __v_200 + __v_201; let __v_203: G = __v_199 - __v_193; let __v_204: G = G::from_bool(__v_203 == G::ZERO); let __v_205: G = __v_202 - __v_194; let __v_206: G = G::from_bool(__v_205 == G::ZERO); let __v_207: G = __v_204 * __v_206; if (__v_207 != __v_190) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_190.as_canonical_u64(), msg: None }); } let __v_208: G = __v_9 + __v_190; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_30, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_208, __v_36, __v_37, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, &__args[..])?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_209]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } const INPUT_SIZE_201: usize = 3; const IN_201: usize = 3; const OUT_201: usize = 2; -fn aiur_fn_201(inp: [G; IN_201], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_201] = [__v_13, __v_13]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_5); let __v_15: G = G::from_u64(65536); let __v_16: G = (__v_15 * __v_6); let __v_17: G = G::from_u64(16777216); let __v_18: G = (__v_17 * __v_7); let __v_19: G = G::from_u64(4294967296); let __v_20: G = (__v_19 * __v_8); let __v_21: G = G::from_u64(1099511627776); let __v_22: G = (__v_21 * __v_9); let __v_23: G = G::from_u64(281474976710656); let __v_24: G = (__v_23 * __v_10); let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = (__v_25 * __v_11); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_22 + __v_27); let __v_29: G = (__v_20 + __v_28); let __v_30: G = (__v_18 + __v_29); let __v_31: G = (__v_16 + __v_30); let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_4 + __v_32); let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); let __v_38: G = G::from_u64(7); let __v_39: G = (__v_1 * __v_36); let __v_40: G = (__v_38 * __v_39); let __v_41: G = (__v_37 + __v_40); let __v_42: G = (__v_0 * __v_36); let __v_43: G = (__v_1 * __v_35); let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_33 + __v_41); let __v_46: G = (__v_34 + __v_44); let __ret: [G; OUT_201] = [__v_45, __v_46]; record.function_queries[201].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_201(inp: [G; IN_201], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_201] = [__v_13, __v_13]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = G::from_u64(256); let __v_14: G = __v_13 * __v_5; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_6; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_7; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_8; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_9; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_10; let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = __v_25 * __v_11; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_22 + __v_27; let __v_29: G = __v_20 + __v_28; let __v_30: G = __v_18 + __v_29; let __v_31: G = __v_16 + __v_30; let __v_32: G = __v_14 + __v_31; let __v_33: G = __v_4 + __v_32; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __v_0 * __v_35; let __v_38: G = G::from_u64(7); let __v_39: G = __v_1 * __v_36; let __v_40: G = __v_38 * __v_39; let __v_41: G = __v_37 + __v_40; let __v_42: G = __v_0 * __v_36; let __v_43: G = __v_1 * __v_35; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_33 + __v_41; let __v_46: G = __v_34 + __v_44; let __ret: [G; OUT_201] = [__v_45, __v_46]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_202: usize = 7; const IN_202: usize = 7; const OUT_202: usize = 2; -fn aiur_fn_202(inp: [G; IN_202], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_202] = [__v_0, __v_1]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); let __v_13: G = (__v_4 + __v_11); let __v_14: G = (__v_12 * __v_12); let __v_15: G = G::from_u64(7); let __v_16: G = (__v_13 * __v_13); let __v_17: G = (__v_15 * __v_16); let __v_18: G = (__v_14 - __v_17); let __v_19: G = aiur::execute::g_inverse_value(__v_18); let __v_20: G = (__v_18 * __v_19); let __v_21: G = G::from_u64(1); let __v_22: G = (__v_20 - __v_21); let __v_23: G = (__v_18 * __v_22); let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_25: G = (__v_19 * __v_22); if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_26: G = (__v_12 * __v_19); let __v_27: G = (__v_24 - __v_13); let __v_28: G = (__v_27 * __v_19); let __v_29: G = (__v_0 + __v_26); let __v_30: G = (__v_1 + __v_28); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, (&__args[..]))?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { (*(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202])) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_202] = [__v_31, __v_32]; record.function_queries[202].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_202(inp: [G; IN_202], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_202] = [__v_0, __v_1]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __v_3 + __v_10; let __v_13: G = __v_4 + __v_11; let __v_14: G = __v_12 * __v_12; let __v_15: G = G::from_u64(7); let __v_16: G = __v_13 * __v_13; let __v_17: G = __v_15 * __v_16; let __v_18: G = __v_14 - __v_17; let __v_19: G = aiur::execute::g_inverse_value(__v_18); let __v_20: G = __v_18 * __v_19; let __v_21: G = G::from_u64(1); let __v_22: G = __v_20 - __v_21; let __v_23: G = __v_18 * __v_22; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_25: G = __v_19 * __v_22; if (__v_25 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } let __v_26: G = __v_12 * __v_19; let __v_27: G = __v_24 - __v_13; let __v_28: G = __v_27 * __v_19; let __v_29: G = __v_0 + __v_26; let __v_30: G = __v_1 + __v_28; let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, &__args[..])?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_202] = [__v_31, __v_32]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_203: usize = 1; const IN_203: usize = 1; const OUT_203: usize = 1; -fn aiur_fn_203(inp: [G; IN_203], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_4]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); let __v_6: G = (__v_2 * __v_5); let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, (&__args[..]))?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { (*(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203])) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_8]; record.function_queries[203].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_203(inp: [G; IN_203], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_4]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_2 - __v_4; let __v_6: G = __v_2 * __v_5; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, &__args[..])?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_8]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_204: usize = 2; const IN_204: usize = 2; const OUT_204: usize = 1; -fn aiur_fn_204(inp: [G; IN_204], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 11] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_14]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_204] = [__v_16]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 11] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 11)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_18]; record.function_queries[204].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_204(inp: [G; IN_204], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 11] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_14]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { match __v_14.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_204] = [__v_16]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 11] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 11)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_204] = [__v_18]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_205: usize = 2; const IN_205: usize = 2; const OUT_205: usize = 1; -fn aiur_fn_205(inp: [G; IN_205], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_205] = [__v_9]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 4)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_11]; record.function_queries[205].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_205(inp: [G; IN_205], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_7]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_205] = [__v_9]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 4)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_205] = [__v_11]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_206: usize = 2; const IN_206: usize = 2; const OUT_206: usize = 1; -fn aiur_fn_206(inp: [G; IN_206], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_2: G = G::from_u8(__gb[0]); let __v_3: G = G::from_u8(__gb[1]); let __v_4: G = G::from_u8(__gb[2]); let __v_5: G = G::from_u8(__gb[3]); let __v_6: G = G::from_u8(__gb[4]); let __v_7: G = G::from_u8(__gb[5]); let __v_8: G = G::from_u8(__gb[6]); let __v_9: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_10: G = G::from_u64(256); let __v_11: G = (__v_10 * __v_3); let __v_12: G = G::from_u64(65536); let __v_13: G = (__v_12 * __v_4); let __v_14: G = G::from_u64(16777216); let __v_15: G = (__v_14 * __v_5); let __v_16: G = G::from_u64(4294967296); let __v_17: G = (__v_16 * __v_6); let __v_18: G = G::from_u64(1099511627776); let __v_19: G = (__v_18 * __v_7); let __v_20: G = G::from_u64(281474976710656); let __v_21: G = (__v_20 * __v_8); let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = (__v_22 * __v_9); let __v_24: G = (__v_21 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = (__v_17 + __v_25); let __v_27: G = (__v_15 + __v_26); let __v_28: G = (__v_13 + __v_27); let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_2 + __v_29); if (__v_30 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_31: G = G::from_u64(1020); let __v_32: G = (__v_9 - __v_31); let __v_33: G = (__v_8 + __v_32); let __v_34: G = (__v_7 + __v_33); let __v_35: G = (__v_6 + __v_34); let __v_36: G = G::from_bool((__v_35 == G::ZERO)); let __v_37: G = (__v_4 + __v_5); let __v_38: G = (__v_3 + __v_37); let __v_39: G = (__v_2 + __v_38); let __v_40: G = G::from_bool((__v_39 == G::ZERO)); let __v_41: G = G::from_u64(1); let __v_42: G = (__v_41 - __v_40); let __v_43: G = (__v_36 * __v_42); let __v_44: G = (__v_41 - __v_43); if (__v_44 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_45]; record.function_queries[206].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_206(inp: [G; IN_206], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_2: G = G::from_u8(__gb[0]); let __v_3: G = G::from_u8(__gb[1]); let __v_4: G = G::from_u8(__gb[2]); let __v_5: G = G::from_u8(__gb[3]); let __v_6: G = G::from_u8(__gb[4]); let __v_7: G = G::from_u8(__gb[5]); let __v_8: G = G::from_u8(__gb[6]); let __v_9: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_3; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_4; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_5; let __v_16: G = G::from_u64(4294967296); let __v_17: G = __v_16 * __v_6; let __v_18: G = G::from_u64(1099511627776); let __v_19: G = __v_18 * __v_7; let __v_20: G = G::from_u64(281474976710656); let __v_21: G = __v_20 * __v_8; let __v_22: G = G::from_u64(72057594037927936); let __v_23: G = __v_22 * __v_9; let __v_24: G = __v_21 + __v_23; let __v_25: G = __v_19 + __v_24; let __v_26: G = __v_17 + __v_25; let __v_27: G = __v_15 + __v_26; let __v_28: G = __v_13 + __v_27; let __v_29: G = __v_11 + __v_28; let __v_30: G = __v_2 + __v_29; if (__v_30 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_31: G = G::from_u64(1020); let __v_32: G = __v_9 - __v_31; let __v_33: G = __v_8 + __v_32; let __v_34: G = __v_7 + __v_33; let __v_35: G = __v_6 + __v_34; let __v_36: G = G::from_bool(__v_35 == G::ZERO); let __v_37: G = __v_4 + __v_5; let __v_38: G = __v_3 + __v_37; let __v_39: G = __v_2 + __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = G::from_u64(1); let __v_42: G = __v_41 - __v_40; let __v_43: G = __v_36 * __v_42; let __v_44: G = __v_41 - __v_43; if (__v_44 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_45]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_207: usize = 2; const IN_207: usize = 2; const OUT_207: usize = 1; -fn aiur_fn_207(inp: [G; IN_207], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_4]; record.function_queries[207].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_207(inp: [G; IN_207], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_4]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_208: usize = 2; const IN_208: usize = 2; const OUT_208: usize = 1; -fn aiur_fn_208(inp: [G; IN_208], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_208] = [__v_1]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, (&__args[..]))?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { (*(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208])) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_8]; record.function_queries[208].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_208(inp: [G; IN_208], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_208] = [__v_1]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(208, &__args[..])?) { [G::ZERO; OUT_208] } else { let (__hash, __hit) = record.function_queries[208].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[208].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => { aiur_fn_208::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_8]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_209: usize = 5; const IN_209: usize = 5; const OUT_209: usize = 1; -fn aiur_fn_209(inp: [G; IN_209], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, (&__args[..]))?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { (*(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207])) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, (&__args[..]))?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { (*(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171])) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_10]; record.function_queries[209].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_209(inp: [G; IN_209], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(207, &__args[..])?) { [G::ZERO; OUT_207] } else { let (__hash, __hit) = record.function_queries[207].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[207].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => { aiur_fn_207::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(171, &__args[..])?) { [G::ZERO; OUT_171] } else { let (__hash, __hit) = record.function_queries[171].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[171].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => { aiur_fn_171::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_10]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_210: usize = 2; const IN_210: usize = 2; const OUT_210: usize = 1; -fn aiur_fn_210(inp: [G; IN_210], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_210] = [__v_1]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, (&__args[..]))?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { (*(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210])) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __v_4, __v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, (&__args[..]))?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { (*(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209])) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_9]; record.function_queries[210].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_210(inp: [G; IN_210], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_210] = [__v_1]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, &__args[..])?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __v_4, __v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(209, &__args[..])?) { [G::ZERO; OUT_209] } else { let (__hash, __hit) = record.function_queries[209].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[209].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => { aiur_fn_209::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_9]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_211: usize = 2; const IN_211: usize = 2; const OUT_211: usize = 1; -fn aiur_fn_211(inp: [G; IN_211], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, (&__args[..]))?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { (*(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212])) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_4]; record.function_queries[211].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_211(inp: [G; IN_211], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, &__args[..])?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_4]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_212: usize = 2; const IN_212: usize = 2; const OUT_212: usize = 1; -fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_212] = [__v_1]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, (&__args[..]))?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { (*(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212])) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_17]; record.function_queries[212].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_212(inp: [G; IN_212], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_212] = [__v_1]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(212, &__args[..])?) { [G::ZERO; OUT_212] } else { let (__hash, __hit) = record.function_queries[212].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[212].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => { aiur_fn_212::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_17]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_213: usize = 4; const IN_213: usize = 4; const OUT_213: usize = 5; -fn aiur_fn_213(inp: [G; IN_213], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, (&__args[..]))?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { (*(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211])) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, (&__args[..]))?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { (*(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210])) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, (&__args[..]))?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { (*(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206])) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, (&__args[..]))?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { (*(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170])) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, (&__args[..]))?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { (*(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180])) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(117); let __v_15: G = G::from_u64(108); let __v_16: G = G::from_u64(116); let __v_17: G = G::from_u64(105); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(114); let __v_22: G = G::from_u64(107); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(48); let __v_26: G = { let __values: [G; 3] = [__v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_12, __v_24, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_12, __v_23, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_29: G = { let __values: [G; 3] = [__v_12, __v_22, __v_28]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_30: G = { let __values: [G; 3] = [__v_12, __v_21, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_31: G = { let __values: [G; 3] = [__v_12, __v_20, __v_30]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_32: G = { let __values: [G; 3] = [__v_12, __v_16, __v_31]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_33: G = { let __values: [G; 3] = [__v_12, __v_19, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_34: G = { let __values: [G; 3] = [__v_12, __v_18, __v_33]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_35: G = { let __values: [G; 3] = [__v_12, __v_17, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_12, __v_16, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_12, __v_15, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_12, __v_14, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_12, __v_13, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_39, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; let __v_44: G = __r_arr[4]; let __v_45: G = __r_arr[5]; let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; let __v_49: G = __r_arr[9]; let __v_50: G = __r_arr[10]; let __v_51: G = __r_arr[11]; let __v_52: G = __r_arr[12]; let __v_53: G = __r_arr[13]; let __v_54: G = __r_arr[14]; let __v_55: G = __r_arr[15]; let __v_56: G = __r_arr[16]; let __v_57: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_56, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_60, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __v_72: G = __r_arr[11]; let __v_73: G = __r_arr[12]; let __v_74: G = __r_arr[13]; let __v_75: G = __r_arr[14]; let __v_76: G = __r_arr[15]; let __v_77: G = __r_arr[16]; let __v_78: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, (&__args[..]))?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { (*(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168])) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_77, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = G::from_u64(256); let __v_83: G = (__v_82 * __v_41); let __v_84: G = G::from_u64(65536); let __v_85: G = (__v_84 * __v_42); let __v_86: G = G::from_u64(16777216); let __v_87: G = (__v_86 * __v_43); let __v_88: G = G::from_u64(4294967296); let __v_89: G = (__v_88 * __v_44); let __v_90: G = G::from_u64(1099511627776); let __v_91: G = (__v_90 * __v_45); let __v_92: G = G::from_u64(281474976710656); let __v_93: G = (__v_92 * __v_46); let __v_94: G = G::from_u64(72057594037927936); let __v_95: G = (__v_94 * __v_47); let __v_96: G = (__v_93 + __v_95); let __v_97: G = (__v_91 + __v_96); let __v_98: G = (__v_89 + __v_97); let __v_99: G = (__v_87 + __v_98); let __v_100: G = (__v_85 + __v_99); let __v_101: G = (__v_83 + __v_100); let __v_102: G = (__v_40 + __v_101); let __v_103: G = (__v_82 * __v_49); let __v_104: G = (__v_84 * __v_50); let __v_105: G = (__v_86 * __v_51); let __v_106: G = (__v_88 * __v_52); let __v_107: G = (__v_90 * __v_53); let __v_108: G = (__v_92 * __v_54); let __v_109: G = (__v_94 * __v_55); let __v_110: G = (__v_108 + __v_109); let __v_111: G = (__v_107 + __v_110); let __v_112: G = (__v_106 + __v_111); let __v_113: G = (__v_105 + __v_112); let __v_114: G = (__v_104 + __v_113); let __v_115: G = (__v_103 + __v_114); let __v_116: G = (__v_48 + __v_115); let __v_117: G = (__v_82 * __v_62); let __v_118: G = (__v_84 * __v_63); let __v_119: G = (__v_86 * __v_64); let __v_120: G = (__v_88 * __v_65); let __v_121: G = (__v_90 * __v_66); let __v_122: G = (__v_92 * __v_67); let __v_123: G = (__v_94 * __v_68); let __v_124: G = (__v_122 + __v_123); let __v_125: G = (__v_121 + __v_124); let __v_126: G = (__v_120 + __v_125); let __v_127: G = (__v_119 + __v_126); let __v_128: G = (__v_118 + __v_127); let __v_129: G = (__v_117 + __v_128); let __v_130: G = (__v_61 + __v_129); let __v_131: G = (__v_82 * __v_70); let __v_132: G = (__v_84 * __v_71); let __v_133: G = (__v_86 * __v_72); let __v_134: G = (__v_88 * __v_73); let __v_135: G = (__v_90 * __v_74); let __v_136: G = (__v_92 * __v_75); let __v_137: G = (__v_94 * __v_76); let __v_138: G = (__v_136 + __v_137); let __v_139: G = (__v_135 + __v_138); let __v_140: G = (__v_134 + __v_139); let __v_141: G = (__v_133 + __v_140); let __v_142: G = (__v_132 + __v_141); let __v_143: G = (__v_131 + __v_142); let __v_144: G = (__v_69 + __v_143); let __ret: [G; OUT_213] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[213].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_213(inp: [G; IN_213], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(211, &__args[..])?) { [G::ZERO; OUT_211] } else { let (__hash, __hit) = record.function_queries[211].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[211].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => { aiur_fn_211::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(210, &__args[..])?) { [G::ZERO; OUT_210] } else { let (__hash, __hit) = record.function_queries[210].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[210].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => { aiur_fn_210::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(206, &__args[..])?) { [G::ZERO; OUT_206] } else { let (__hash, __hit) = record.function_queries[206].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[206].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => { aiur_fn_206::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(170, &__args[..])?) { [G::ZERO; OUT_170] } else { let (__hash, __hit) = record.function_queries[170].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[170].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => { aiur_fn_170::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(180, &__args[..])?) { [G::ZERO; OUT_180] } else { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[180].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => { aiur_fn_180::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(109); let __v_14: G = G::from_u64(117); let __v_15: G = G::from_u64(108); let __v_16: G = G::from_u64(116); let __v_17: G = G::from_u64(105); let __v_18: G = G::from_u64(45); let __v_19: G = G::from_u64(115); let __v_20: G = G::from_u64(97); let __v_21: G = G::from_u64(114); let __v_22: G = G::from_u64(107); let __v_23: G = G::from_u64(47); let __v_24: G = G::from_u64(118); let __v_25: G = G::from_u64(48); let __v_26: G = { let __values: [G; 3] = [__v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_27: G = { let __values: [G; 3] = [__v_12, __v_24, __v_26]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_28: G = { let __values: [G; 3] = [__v_12, __v_23, __v_27]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_29: G = { let __values: [G; 3] = [__v_12, __v_22, __v_28]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_30: G = { let __values: [G; 3] = [__v_12, __v_21, __v_29]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_31: G = { let __values: [G; 3] = [__v_12, __v_20, __v_30]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_32: G = { let __values: [G; 3] = [__v_12, __v_16, __v_31]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_33: G = { let __values: [G; 3] = [__v_12, __v_19, __v_32]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_34: G = { let __values: [G; 3] = [__v_12, __v_18, __v_33]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_35: G = { let __values: [G; 3] = [__v_12, __v_17, __v_34]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_36: G = { let __values: [G; 3] = [__v_12, __v_16, __v_35]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_37: G = { let __values: [G; 3] = [__v_12, __v_15, __v_36]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_38: G = { let __values: [G; 3] = [__v_12, __v_14, __v_37]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_39: G = { let __values: [G; 3] = [__v_12, __v_13, __v_38]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_39, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; let __v_44: G = __r_arr[4]; let __v_45: G = __r_arr[5]; let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; let __v_49: G = __r_arr[9]; let __v_50: G = __r_arr[10]; let __v_51: G = __r_arr[11]; let __v_52: G = __r_arr[12]; let __v_53: G = __r_arr[13]; let __v_54: G = __r_arr[14]; let __v_55: G = __r_arr[15]; let __v_56: G = __r_arr[16]; let __v_57: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_56, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_60, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __v_64: G = __r_arr[3]; let __v_65: G = __r_arr[4]; let __v_66: G = __r_arr[5]; let __v_67: G = __r_arr[6]; let __v_68: G = __r_arr[7]; let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; let __v_72: G = __r_arr[11]; let __v_73: G = __r_arr[12]; let __v_74: G = __r_arr[13]; let __v_75: G = __r_arr[14]; let __v_76: G = __r_arr[15]; let __v_77: G = __r_arr[16]; let __v_78: G = __r_arr[17]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(168, &__args[..])?) { [G::ZERO; OUT_168] } else { let (__hash, __hit) = record.function_queries[168].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[168].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => { aiur_fn_168::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_77, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_41; let __v_84: G = G::from_u64(65536); let __v_85: G = __v_84 * __v_42; let __v_86: G = G::from_u64(16777216); let __v_87: G = __v_86 * __v_43; let __v_88: G = G::from_u64(4294967296); let __v_89: G = __v_88 * __v_44; let __v_90: G = G::from_u64(1099511627776); let __v_91: G = __v_90 * __v_45; let __v_92: G = G::from_u64(281474976710656); let __v_93: G = __v_92 * __v_46; let __v_94: G = G::from_u64(72057594037927936); let __v_95: G = __v_94 * __v_47; let __v_96: G = __v_93 + __v_95; let __v_97: G = __v_91 + __v_96; let __v_98: G = __v_89 + __v_97; let __v_99: G = __v_87 + __v_98; let __v_100: G = __v_85 + __v_99; let __v_101: G = __v_83 + __v_100; let __v_102: G = __v_40 + __v_101; let __v_103: G = __v_82 * __v_49; let __v_104: G = __v_84 * __v_50; let __v_105: G = __v_86 * __v_51; let __v_106: G = __v_88 * __v_52; let __v_107: G = __v_90 * __v_53; let __v_108: G = __v_92 * __v_54; let __v_109: G = __v_94 * __v_55; let __v_110: G = __v_108 + __v_109; let __v_111: G = __v_107 + __v_110; let __v_112: G = __v_106 + __v_111; let __v_113: G = __v_105 + __v_112; let __v_114: G = __v_104 + __v_113; let __v_115: G = __v_103 + __v_114; let __v_116: G = __v_48 + __v_115; let __v_117: G = __v_82 * __v_62; let __v_118: G = __v_84 * __v_63; let __v_119: G = __v_86 * __v_64; let __v_120: G = __v_88 * __v_65; let __v_121: G = __v_90 * __v_66; let __v_122: G = __v_92 * __v_67; let __v_123: G = __v_94 * __v_68; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_121 + __v_124; let __v_126: G = __v_120 + __v_125; let __v_127: G = __v_119 + __v_126; let __v_128: G = __v_118 + __v_127; let __v_129: G = __v_117 + __v_128; let __v_130: G = __v_61 + __v_129; let __v_131: G = __v_82 * __v_70; let __v_132: G = __v_84 * __v_71; let __v_133: G = __v_86 * __v_72; let __v_134: G = __v_88 * __v_73; let __v_135: G = __v_90 * __v_74; let __v_136: G = __v_92 * __v_75; let __v_137: G = __v_94 * __v_76; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_135 + __v_138; let __v_140: G = __v_134 + __v_139; let __v_141: G = __v_133 + __v_140; let __v_142: G = __v_132 + __v_141; let __v_143: G = __v_131 + __v_142; let __v_144: G = __v_69 + __v_143; let __ret: [G; OUT_213] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_214: usize = 5; const IN_214: usize = 5; const OUT_214: usize = 5; -fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_5: G = G::from_u8(__gb[0]); let __v_6: G = G::from_u8(__gb[1]); let __v_7: G = G::from_u8(__gb[2]); let __v_8: G = G::from_u8(__gb[3]); let __v_9: G = G::from_u8(__gb[4]); let __v_10: G = G::from_u8(__gb[5]); let __v_11: G = G::from_u8(__gb[6]); let __v_12: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_11; let __vj = __v_12; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_6); let __v_15: G = G::from_u64(65536); let __v_16: G = (__v_15 * __v_7); let __v_17: G = G::from_u64(16777216); let __v_18: G = (__v_17 * __v_8); let __v_19: G = G::from_u64(4294967296); let __v_20: G = (__v_19 * __v_9); let __v_21: G = G::from_u64(1099511627776); let __v_22: G = (__v_21 * __v_10); let __v_23: G = G::from_u64(281474976710656); let __v_24: G = (__v_23 * __v_11); let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = (__v_25 * __v_12); let __v_27: G = (__v_24 + __v_26); let __v_28: G = (__v_22 + __v_27); let __v_29: G = (__v_20 + __v_28); let __v_30: G = (__v_18 + __v_29); let __v_31: G = (__v_16 + __v_30); let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_5 + __v_32); if (__v_33 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_34: G = G::from_u64(1020); let __v_35: G = (__v_12 - __v_34); let __v_36: G = (__v_11 + __v_35); let __v_37: G = (__v_10 + __v_36); let __v_38: G = (__v_9 + __v_37); let __v_39: G = G::from_bool((__v_38 == G::ZERO)); let __v_40: G = (__v_7 + __v_8); let __v_41: G = (__v_6 + __v_40); let __v_42: G = (__v_5 + __v_41); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); let __v_44: G = G::from_u64(1); let __v_45: G = (__v_44 - __v_43); let __v_46: G = (__v_39 * __v_45); let __v_47: G = (__v_44 - __v_46); if (__v_47 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, (&__args[..]))?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { (*(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177])) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 3] = [__v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_49, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_52, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, (&__args[..]))?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { (*(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178])) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_71, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __v_83: G = __r_arr[11]; let __v_84: G = __r_arr[12]; let __v_85: G = __r_arr[13]; let __v_86: G = __r_arr[14]; let __v_87: G = __r_arr[15]; let __v_88: G = __r_arr[16]; let __v_89: G = __r_arr[17]; let __v_90: G = (__v_13 * __v_54); let __v_91: G = (__v_15 * __v_55); let __v_92: G = (__v_17 * __v_56); let __v_93: G = (__v_19 * __v_57); let __v_94: G = (__v_21 * __v_58); let __v_95: G = (__v_23 * __v_59); let __v_96: G = (__v_25 * __v_60); let __v_97: G = (__v_95 + __v_96); let __v_98: G = (__v_94 + __v_97); let __v_99: G = (__v_93 + __v_98); let __v_100: G = (__v_92 + __v_99); let __v_101: G = (__v_91 + __v_100); let __v_102: G = (__v_90 + __v_101); let __v_103: G = (__v_53 + __v_102); let __v_104: G = (__v_13 * __v_62); let __v_105: G = (__v_15 * __v_63); let __v_106: G = (__v_17 * __v_64); let __v_107: G = (__v_19 * __v_65); let __v_108: G = (__v_21 * __v_66); let __v_109: G = (__v_23 * __v_67); let __v_110: G = (__v_25 * __v_68); let __v_111: G = (__v_109 + __v_110); let __v_112: G = (__v_108 + __v_111); let __v_113: G = (__v_107 + __v_112); let __v_114: G = (__v_106 + __v_113); let __v_115: G = (__v_105 + __v_114); let __v_116: G = (__v_104 + __v_115); let __v_117: G = (__v_61 + __v_116); let __v_118: G = (__v_13 * __v_73); let __v_119: G = (__v_15 * __v_74); let __v_120: G = (__v_17 * __v_75); let __v_121: G = (__v_19 * __v_76); let __v_122: G = (__v_21 * __v_77); let __v_123: G = (__v_23 * __v_78); let __v_124: G = (__v_25 * __v_79); let __v_125: G = (__v_123 + __v_124); let __v_126: G = (__v_122 + __v_125); let __v_127: G = (__v_121 + __v_126); let __v_128: G = (__v_120 + __v_127); let __v_129: G = (__v_119 + __v_128); let __v_130: G = (__v_118 + __v_129); let __v_131: G = (__v_72 + __v_130); let __v_132: G = (__v_13 * __v_81); let __v_133: G = (__v_15 * __v_82); let __v_134: G = (__v_17 * __v_83); let __v_135: G = (__v_19 * __v_84); let __v_136: G = (__v_21 * __v_85); let __v_137: G = (__v_23 * __v_86); let __v_138: G = (__v_25 * __v_87); let __v_139: G = (__v_137 + __v_138); let __v_140: G = (__v_136 + __v_139); let __v_141: G = (__v_135 + __v_140); let __v_142: G = (__v_134 + __v_141); let __v_143: G = (__v_133 + __v_142); let __v_144: G = (__v_132 + __v_143); let __v_145: G = (__v_80 + __v_144); let __ret: [G; OUT_214] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[214].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_214(inp: [G; IN_214], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_5: G = G::from_u8(__gb[0]); let __v_6: G = G::from_u8(__gb[1]); let __v_7: G = G::from_u8(__gb[2]); let __v_8: G = G::from_u8(__gb[3]); let __v_9: G = G::from_u8(__gb[4]); let __v_10: G = G::from_u8(__gb[5]); let __v_11: G = G::from_u8(__gb[6]); let __v_12: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_11; let __vj = __v_12; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_13: G = G::from_u64(256); let __v_14: G = __v_13 * __v_6; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_7; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_8; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_9; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_10; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_11; let __v_25: G = G::from_u64(72057594037927936); let __v_26: G = __v_25 * __v_12; let __v_27: G = __v_24 + __v_26; let __v_28: G = __v_22 + __v_27; let __v_29: G = __v_20 + __v_28; let __v_30: G = __v_18 + __v_29; let __v_31: G = __v_16 + __v_30; let __v_32: G = __v_14 + __v_31; let __v_33: G = __v_5 + __v_32; if (__v_33 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_34: G = G::from_u64(1020); let __v_35: G = __v_12 - __v_34; let __v_36: G = __v_11 + __v_35; let __v_37: G = __v_10 + __v_36; let __v_38: G = __v_9 + __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = __v_7 + __v_8; let __v_41: G = __v_6 + __v_40; let __v_42: G = __v_5 + __v_41; let __v_43: G = G::from_bool(__v_42 == G::ZERO); let __v_44: G = G::from_u64(1); let __v_45: G = __v_44 - __v_43; let __v_46: G = __v_39 * __v_45; let __v_47: G = __v_44 - __v_46; if (__v_47 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(177, &__args[..])?) { [G::ZERO; OUT_177] } else { let (__hash, __hit) = record.function_queries[177].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[177].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => { aiur_fn_177::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 3] = [__v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_49, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_52, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; let __v_56: G = __r_arr[3]; let __v_57: G = __r_arr[4]; let __v_58: G = __r_arr[5]; let __v_59: G = __r_arr[6]; let __v_60: G = __r_arr[7]; let __v_61: G = __r_arr[8]; let __v_62: G = __r_arr[9]; let __v_63: G = __r_arr[10]; let __v_64: G = __r_arr[11]; let __v_65: G = __r_arr[12]; let __v_66: G = __r_arr[13]; let __v_67: G = __r_arr[14]; let __v_68: G = __r_arr[15]; let __v_69: G = __r_arr[16]; let __v_70: G = __r_arr[17]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(178, &__args[..])?) { [G::ZERO; OUT_178] } else { let (__hash, __hit) = record.function_queries[178].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[178].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => { aiur_fn_178::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_71, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; let __v_75: G = __r_arr[3]; let __v_76: G = __r_arr[4]; let __v_77: G = __r_arr[5]; let __v_78: G = __r_arr[6]; let __v_79: G = __r_arr[7]; let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; let __v_83: G = __r_arr[11]; let __v_84: G = __r_arr[12]; let __v_85: G = __r_arr[13]; let __v_86: G = __r_arr[14]; let __v_87: G = __r_arr[15]; let __v_88: G = __r_arr[16]; let __v_89: G = __r_arr[17]; let __v_90: G = __v_13 * __v_54; let __v_91: G = __v_15 * __v_55; let __v_92: G = __v_17 * __v_56; let __v_93: G = __v_19 * __v_57; let __v_94: G = __v_21 * __v_58; let __v_95: G = __v_23 * __v_59; let __v_96: G = __v_25 * __v_60; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_94 + __v_97; let __v_99: G = __v_93 + __v_98; let __v_100: G = __v_92 + __v_99; let __v_101: G = __v_91 + __v_100; let __v_102: G = __v_90 + __v_101; let __v_103: G = __v_53 + __v_102; let __v_104: G = __v_13 * __v_62; let __v_105: G = __v_15 * __v_63; let __v_106: G = __v_17 * __v_64; let __v_107: G = __v_19 * __v_65; let __v_108: G = __v_21 * __v_66; let __v_109: G = __v_23 * __v_67; let __v_110: G = __v_25 * __v_68; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_108 + __v_111; let __v_113: G = __v_107 + __v_112; let __v_114: G = __v_106 + __v_113; let __v_115: G = __v_105 + __v_114; let __v_116: G = __v_104 + __v_115; let __v_117: G = __v_61 + __v_116; let __v_118: G = __v_13 * __v_73; let __v_119: G = __v_15 * __v_74; let __v_120: G = __v_17 * __v_75; let __v_121: G = __v_19 * __v_76; let __v_122: G = __v_21 * __v_77; let __v_123: G = __v_23 * __v_78; let __v_124: G = __v_25 * __v_79; let __v_125: G = __v_123 + __v_124; let __v_126: G = __v_122 + __v_125; let __v_127: G = __v_121 + __v_126; let __v_128: G = __v_120 + __v_127; let __v_129: G = __v_119 + __v_128; let __v_130: G = __v_118 + __v_129; let __v_131: G = __v_72 + __v_130; let __v_132: G = __v_13 * __v_81; let __v_133: G = __v_15 * __v_82; let __v_134: G = __v_17 * __v_83; let __v_135: G = __v_19 * __v_84; let __v_136: G = __v_21 * __v_85; let __v_137: G = __v_23 * __v_86; let __v_138: G = __v_25 * __v_87; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_136 + __v_139; let __v_141: G = __v_135 + __v_140; let __v_142: G = __v_134 + __v_141; let __v_143: G = __v_133 + __v_142; let __v_144: G = __v_132 + __v_143; let __v_145: G = __v_80 + __v_144; let __ret: [G; OUT_214] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_215: usize = 2; const IN_215: usize = 2; const OUT_215: usize = 1; -fn aiur_fn_215(inp: [G; IN_215], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_215] = [__v_8]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { if (__v_3 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_8]; record.function_queries[215].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_215(inp: [G; IN_215], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_215] = [__v_8]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { if (__v_3 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_8]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_216: usize = 2; const IN_216: usize = 2; const OUT_216: usize = 1; -fn aiur_fn_216(inp: [G; IN_216], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = G::from_u64(1); if (__v_12 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_13 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_14 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_15 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_16 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_17 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_18 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_19 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_20 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_216] = [__v_22]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, (&__args[..]))?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { (*(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216])) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_216] = [__v_24]; record.function_queries[216].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_216(inp: [G; IN_216], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = G::from_u64(1); if (__v_12 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_13 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_14 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_15 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_16 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_17 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_18 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_19 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_20 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_216] = [__v_22]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, &__args[..])?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_216] = [__v_24]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_217: usize = 2; const IN_217: usize = 2; const OUT_217: usize = 1; -fn aiur_fn_217(inp: [G; IN_217], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_217] = [__v_8]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, (&__args[..]))?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { (*(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216])) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_10]; record.function_queries[217].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_217(inp: [G; IN_217], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_217] = [__v_8]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(216, &__args[..])?) { [G::ZERO; OUT_216] } else { let (__hash, __hit) = record.function_queries[216].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[216].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => { aiur_fn_216::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_10]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_218: usize = 2; const IN_218: usize = 2; const OUT_218: usize = 1; -fn aiur_fn_218(inp: [G; IN_218], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_218] = [__v_8]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; let __v_43: G = __loaded[3]; let __v_44: G = __loaded[4]; let __v_45: G = __loaded[5]; let __v_46: G = __loaded[6]; let __v_47: G = __loaded[7]; let __v_48: G = __loaded[8]; let __v_49: G = __loaded[9]; let __v_50: G = __loaded[10]; let __v_51: G = __loaded[11]; let __v_52: G = __loaded[12]; let __v_53: G = __loaded[13]; let __v_54: G = __loaded[14]; let __v_55: G = __loaded[15]; let __v_56: G = __loaded[16]; let __v_57: G = __loaded[17]; let __v_58: G = __loaded[18]; let __v_59: G = __loaded[19]; let __v_60: G = __loaded[20]; let __v_61: G = __loaded[21]; let __v_62: G = __loaded[22]; let __v_63: G = __loaded[23]; let __v_64: G = __loaded[24]; let __v_65: G = __loaded[25]; let __v_66: G = __loaded[26]; let __v_67: G = __loaded[27]; let __v_68: G = __loaded[28]; let __v_69: G = __loaded[29]; let __v_70: G = __loaded[30]; let __v_71: G = __loaded[31]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; if (__v_74 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; if (__v_75 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, (&__args[..]))?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { (*(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10])) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_77]; record.function_queries[218].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_218(inp: [G; IN_218], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_6 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_218] = [__v_8]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; let __v_43: G = __loaded[3]; let __v_44: G = __loaded[4]; let __v_45: G = __loaded[5]; let __v_46: G = __loaded[6]; let __v_47: G = __loaded[7]; let __v_48: G = __loaded[8]; let __v_49: G = __loaded[9]; let __v_50: G = __loaded[10]; let __v_51: G = __loaded[11]; let __v_52: G = __loaded[12]; let __v_53: G = __loaded[13]; let __v_54: G = __loaded[14]; let __v_55: G = __loaded[15]; let __v_56: G = __loaded[16]; let __v_57: G = __loaded[17]; let __v_58: G = __loaded[18]; let __v_59: G = __loaded[19]; let __v_60: G = __loaded[20]; let __v_61: G = __loaded[21]; let __v_62: G = __loaded[22]; let __v_63: G = __loaded[23]; let __v_64: G = __loaded[24]; let __v_65: G = __loaded[25]; let __v_66: G = __loaded[26]; let __v_67: G = __loaded[27]; let __v_68: G = __loaded[28]; let __v_69: G = __loaded[29]; let __v_70: G = __loaded[30]; let __v_71: G = __loaded[31]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; if (__v_74 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; if (__v_75 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(10, &__args[..])?) { [G::ZERO; OUT_10] } else { let (__hash, __hit) = record.function_queries[10].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[10].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[10].bump_multiplicity(__i); } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => { aiur_fn_10::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_77]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_219: usize = 1; const IN_219: usize = 1; const OUT_219: usize = 2; -fn aiur_fn_219(inp: [G; IN_219], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_219] = [__v_2, __v_3]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_219] = [__v_9, __v_10]; record.function_queries[219].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_219(inp: [G; IN_219], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_219] = [__v_2, __v_3]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, &__args[..])?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_219] = [__v_9, __v_10]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_220: usize = 7; const IN_220: usize = 7; const OUT_220: usize = 2; -fn aiur_fn_220(inp: [G; IN_220], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_220] = [__v_0, __v_1]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, (&__args[..]))?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { (*(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201])) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = (__v_3 + __v_18); let __v_21: G = (__v_4 + __v_19); let __v_22: G = (__v_20 * __v_20); let __v_23: G = G::from_u64(7); let __v_24: G = (__v_21 * __v_21); let __v_25: G = (__v_23 * __v_24); let __v_26: G = (__v_22 - __v_25); let __v_27: G = aiur::execute::g_inverse_value(__v_26); let __v_28: G = (__v_26 * __v_27); let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = (__v_26 * __v_30); let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_33: G = (__v_27 * __v_30); if (__v_33 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_34: G = (__v_20 * __v_27); let __v_35: G = (__v_32 - __v_21); let __v_36: G = (__v_35 * __v_27); let __v_37: G = G::from_u64(256); let __v_38: G = (__v_37 * __v_10); let __v_39: G = G::from_u64(65536); let __v_40: G = (__v_39 * __v_11); let __v_41: G = G::from_u64(16777216); let __v_42: G = (__v_41 * __v_12); let __v_43: G = G::from_u64(4294967296); let __v_44: G = (__v_43 * __v_13); let __v_45: G = G::from_u64(1099511627776); let __v_46: G = (__v_45 * __v_14); let __v_47: G = G::from_u64(281474976710656); let __v_48: G = (__v_47 * __v_15); let __v_49: G = G::from_u64(72057594037927936); let __v_50: G = (__v_49 * __v_16); let __v_51: G = (__v_48 + __v_50); let __v_52: G = (__v_46 + __v_51); let __v_53: G = (__v_44 + __v_52); let __v_54: G = (__v_42 + __v_53); let __v_55: G = (__v_40 + __v_54); let __v_56: G = (__v_38 + __v_55); let __v_57: G = (__v_9 + __v_56); let __v_58: G = (__v_34 * __v_57); let __v_59: G = (__v_36 * __v_32); let __v_60: G = (__v_23 * __v_59); let __v_61: G = (__v_58 + __v_60); let __v_62: G = (__v_34 * __v_32); let __v_63: G = (__v_36 * __v_57); let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_0 + __v_61); let __v_66: G = (__v_1 + __v_64); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, (&__args[..]))?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { (*(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220])) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_220] = [__v_67, __v_68]; record.function_queries[220].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } +fn aiur_fn_220(inp: [G; IN_220], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_220] = [__v_0, __v_1]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(201, &__args[..])?) { [G::ZERO; OUT_201] } else { let (__hash, __hit) = record.function_queries[201].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[201].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => { aiur_fn_201::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __v_3 + __v_18; let __v_21: G = __v_4 + __v_19; let __v_22: G = __v_20 * __v_20; let __v_23: G = G::from_u64(7); let __v_24: G = __v_21 * __v_21; let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 - __v_25; let __v_27: G = aiur::execute::g_inverse_value(__v_26); let __v_28: G = __v_26 * __v_27; let __v_29: G = G::from_u64(1); let __v_30: G = __v_28 - __v_29; let __v_31: G = __v_26 * __v_30; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_33: G = __v_27 * __v_30; if (__v_33 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); } let __v_34: G = __v_20 * __v_27; let __v_35: G = __v_32 - __v_21; let __v_36: G = __v_35 * __v_27; let __v_37: G = G::from_u64(256); let __v_38: G = __v_37 * __v_10; let __v_39: G = G::from_u64(65536); let __v_40: G = __v_39 * __v_11; let __v_41: G = G::from_u64(16777216); let __v_42: G = __v_41 * __v_12; let __v_43: G = G::from_u64(4294967296); let __v_44: G = __v_43 * __v_13; let __v_45: G = G::from_u64(1099511627776); let __v_46: G = __v_45 * __v_14; let __v_47: G = G::from_u64(281474976710656); let __v_48: G = __v_47 * __v_15; let __v_49: G = G::from_u64(72057594037927936); let __v_50: G = __v_49 * __v_16; let __v_51: G = __v_48 + __v_50; let __v_52: G = __v_46 + __v_51; let __v_53: G = __v_44 + __v_52; let __v_54: G = __v_42 + __v_53; let __v_55: G = __v_40 + __v_54; let __v_56: G = __v_38 + __v_55; let __v_57: G = __v_9 + __v_56; let __v_58: G = __v_34 * __v_57; let __v_59: G = __v_36 * __v_32; let __v_60: G = __v_23 * __v_59; let __v_61: G = __v_58 + __v_60; let __v_62: G = __v_34 * __v_32; let __v_63: G = __v_36 * __v_57; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_0 + __v_61; let __v_66: G = __v_1 + __v_64; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, &__args[..])?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_220] = [__v_67, __v_68]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } const INPUT_SIZE_221: usize = 1; const IN_221: usize = 1; const OUT_221: usize = 1; -fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_221(inp: [G; IN_221], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_1]; record.function_queries[221].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_222: usize = 1; const IN_222: usize = 1; const OUT_222: usize = 1; -fn aiur_fn_222(inp: [G; IN_222], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_222] = [__v_4]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, (&__args[..]))?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { (*(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221])) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, (&__args[..]))?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { (*(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222])) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_6]; record.function_queries[222].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_222(inp: [G; IN_222], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_222] = [__v_4]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(221, &__args[..])?) { [G::ZERO; OUT_221] } else { let (__hash, __hit) = record.function_queries[221].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[221].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => { aiur_fn_221::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, &__args[..])?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_6]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_223: usize = 1; const IN_223: usize = 1; const OUT_223: usize = 1; -fn aiur_fn_223(inp: [G; IN_223], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_223] = [__v_4]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, (&__args[..]))?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { (*(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223])) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_2 + __v_4); let __ret: [G; OUT_223] = [__v_5]; record.function_queries[223].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_223(inp: [G; IN_223], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_223] = [__v_4]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, &__args[..])?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_2 + __v_4; let __ret: [G; OUT_223] = [__v_5]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_224: usize = 1; const IN_224: usize = 1; const OUT_224: usize = 1; -fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = G::from_bool((__v_0 == G::ZERO)); let __v_2: G = G::from_u64(0); if (__v_1 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_3: G = G::from_u8(__gb[0]); let __v_4: G = G::from_u8(__gb[1]); let __v_5: G = G::from_u8(__gb[2]); let __v_6: G = G::from_u8(__gb[3]); let __v_7: G = G::from_u8(__gb[4]); let __v_8: G = G::from_u8(__gb[5]); let __v_9: G = G::from_u8(__gb[6]); let __v_10: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_11: G = G::from_u64(256); let __v_12: G = (__v_11 * __v_4); let __v_13: G = G::from_u64(65536); let __v_14: G = (__v_13 * __v_5); let __v_15: G = G::from_u64(16777216); let __v_16: G = (__v_15 * __v_6); let __v_17: G = G::from_u64(4294967296); let __v_18: G = (__v_17 * __v_7); let __v_19: G = G::from_u64(1099511627776); let __v_20: G = (__v_19 * __v_8); let __v_21: G = G::from_u64(281474976710656); let __v_22: G = (__v_21 * __v_9); let __v_23: G = G::from_u64(72057594037927936); let __v_24: G = (__v_23 * __v_10); let __v_25: G = (__v_22 + __v_24); let __v_26: G = (__v_20 + __v_25); let __v_27: G = (__v_18 + __v_26); let __v_28: G = (__v_16 + __v_27); let __v_29: G = (__v_14 + __v_28); let __v_30: G = (__v_12 + __v_29); let __v_31: G = (__v_3 + __v_30); if (__v_31 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1020); let __v_33: G = (__v_10 - __v_32); let __v_34: G = (__v_9 + __v_33); let __v_35: G = (__v_8 + __v_34); let __v_36: G = (__v_7 + __v_35); let __v_37: G = G::from_bool((__v_36 == G::ZERO)); let __v_38: G = (__v_5 + __v_6); let __v_39: G = (__v_4 + __v_38); let __v_40: G = (__v_3 + __v_39); let __v_41: G = G::from_bool((__v_40 == G::ZERO)); let __v_42: G = G::from_u64(1); let __v_43: G = (__v_42 - __v_41); let __v_44: G = (__v_37 * __v_43); let __v_45: G = (__v_42 - __v_44); if (__v_45 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_46: G = (__v_9 + __v_10); let __v_47: G = (__v_8 + __v_46); let __v_48: G = (__v_7 + __v_47); let __v_49: G = (__v_6 + __v_48); if (__v_49 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_50: G = (__v_5 - __v_42); let __v_51: G = (__v_5 * __v_50); if (__v_51 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_52: G = (__v_3 + __v_4); let __v_53: G = (__v_5 * __v_52); if (__v_53 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_224] = [__v_42]; record.function_queries[224].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_224(inp: [G; IN_224], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = G::from_bool(__v_0 == G::ZERO); let __v_2: G = G::from_u64(0); if (__v_1 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_3: G = G::from_u8(__gb[0]); let __v_4: G = G::from_u8(__gb[1]); let __v_5: G = G::from_u8(__gb[2]); let __v_6: G = G::from_u8(__gb[3]); let __v_7: G = G::from_u8(__gb[4]); let __v_8: G = G::from_u8(__gb[5]); let __v_9: G = G::from_u8(__gb[6]); let __v_10: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_11: G = G::from_u64(256); let __v_12: G = __v_11 * __v_4; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_5; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_6; let __v_17: G = G::from_u64(4294967296); let __v_18: G = __v_17 * __v_7; let __v_19: G = G::from_u64(1099511627776); let __v_20: G = __v_19 * __v_8; let __v_21: G = G::from_u64(281474976710656); let __v_22: G = __v_21 * __v_9; let __v_23: G = G::from_u64(72057594037927936); let __v_24: G = __v_23 * __v_10; let __v_25: G = __v_22 + __v_24; let __v_26: G = __v_20 + __v_25; let __v_27: G = __v_18 + __v_26; let __v_28: G = __v_16 + __v_27; let __v_29: G = __v_14 + __v_28; let __v_30: G = __v_12 + __v_29; let __v_31: G = __v_3 + __v_30; if (__v_31 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1020); let __v_33: G = __v_10 - __v_32; let __v_34: G = __v_9 + __v_33; let __v_35: G = __v_8 + __v_34; let __v_36: G = __v_7 + __v_35; let __v_37: G = G::from_bool(__v_36 == G::ZERO); let __v_38: G = __v_5 + __v_6; let __v_39: G = __v_4 + __v_38; let __v_40: G = __v_3 + __v_39; let __v_41: G = G::from_bool(__v_40 == G::ZERO); let __v_42: G = G::from_u64(1); let __v_43: G = __v_42 - __v_41; let __v_44: G = __v_37 * __v_43; let __v_45: G = __v_42 - __v_44; if (__v_45 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None }); } let __v_46: G = __v_9 + __v_10; let __v_47: G = __v_8 + __v_46; let __v_48: G = __v_7 + __v_47; let __v_49: G = __v_6 + __v_48; if (__v_49 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_50: G = __v_5 - __v_42; let __v_51: G = __v_5 * __v_50; if (__v_51 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_52: G = __v_3 + __v_4; let __v_53: G = __v_5 * __v_52; if (__v_53 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_224] = [__v_42]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_225: usize = 1; const IN_225: usize = 1; const OUT_225: usize = 24; -fn aiur_fn_225(inp: [G; IN_225], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; match __v_21.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = G::from_u64(1); if (__v_31 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_32 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_33 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_34 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_35 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_36 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_37 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_38 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_39 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_40 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_225] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; record.function_queries[225].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_225(inp: [G; IN_225], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; match __v_21.as_canonical_u64() { 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = G::from_u64(1); if (__v_31 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_32 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_33 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_34 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_35 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_36 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_37 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_38 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_39 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } if (__v_40 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_225] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_226: usize = 3; const IN_226: usize = 3; const OUT_226: usize = 1; -fn aiur_fn_226(inp: [G; IN_226], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than((&__v_0), (&__v_1)) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; let __v_4: G = (__v_0 - __v_1); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_5 * __v_2); let __v_7: G = (__v_3 + __v_6); let __ret: [G; OUT_226] = [__v_7]; record.function_queries[226].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_226(inp: [G; IN_226], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_1) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; let __v_4: G = __v_0 - __v_1; let __v_5: G = G::from_bool(__v_4 == G::ZERO); let __v_6: G = __v_5 * __v_2; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_226] = [__v_7]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_227: usize = 16; const IN_227: usize = 16; const OUT_227: usize = 1; -fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1, __v_9, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_10, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_12, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_13, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_15, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, (&__args[..]))?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { (*(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226])) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_24]; record.function_queries[227].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_227(inp: [G; IN_227], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1, __v_9, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_10, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_12, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_13, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_15, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(226, &__args[..])?) { [G::ZERO; OUT_226] } else { let (__hash, __hit) = record.function_queries[226].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[226].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => { aiur_fn_226::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_24]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_228: usize = 3; const IN_228: usize = 3; const OUT_228: usize = 1; -fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_228] = [__v_14]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = __loaded[6]; let __v_21: G = __loaded[7]; let __v_22: G = __loaded[8]; let __v_23: G = __loaded[9]; let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { _ => { let __v_25: G = G::from_u64(256); let __v_26: G = (__v_25 * __v_6); let __v_27: G = G::from_u64(65536); let __v_28: G = (__v_27 * __v_7); let __v_29: G = G::from_u64(16777216); let __v_30: G = (__v_29 * __v_8); let __v_31: G = G::from_u64(4294967296); let __v_32: G = (__v_31 * __v_9); let __v_33: G = G::from_u64(1099511627776); let __v_34: G = (__v_33 * __v_10); let __v_35: G = G::from_u64(281474976710656); let __v_36: G = (__v_35 * __v_11); let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = (__v_37 * __v_12); let __v_39: G = (__v_36 + __v_38); let __v_40: G = (__v_34 + __v_39); let __v_41: G = (__v_32 + __v_40); let __v_42: G = (__v_30 + __v_41); let __v_43: G = (__v_28 + __v_42); let __v_44: G = (__v_26 + __v_43); let __v_45: G = (__v_5 + __v_44); let __v_46: G = G::from_u64(1); let __v_47: G = (__v_45 + __v_46); let __v_48: G = G::from_u64(0); if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __v_49: G = (__v_25 * __v_17); let __v_50: G = (__v_27 * __v_18); let __v_51: G = (__v_29 * __v_19); let __v_52: G = (__v_31 * __v_20); let __v_53: G = (__v_33 * __v_21); let __v_54: G = (__v_35 * __v_22); let __v_55: G = (__v_37 * __v_23); let __v_56: G = (__v_54 + __v_55); let __v_57: G = (__v_53 + __v_56); let __v_58: G = (__v_52 + __v_57); let __v_59: G = (__v_51 + __v_58); let __v_60: G = (__v_50 + __v_59); let __v_61: G = (__v_49 + __v_60); let __v_62: G = (__v_16 + __v_61); if (__v_62 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, (&__args[..]))?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { (*(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225])) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __v_67: G = __r_arr[4]; let __v_68: G = __r_arr[5]; let __v_69: G = __r_arr[6]; let __v_70: G = __r_arr[7]; let __v_71: G = __r_arr[8]; let __v_72: G = __r_arr[9]; let __v_73: G = __r_arr[10]; let __v_74: G = __r_arr[11]; let __v_75: G = __r_arr[12]; let __v_76: G = __r_arr[13]; let __v_77: G = __r_arr[14]; let __v_78: G = __r_arr[15]; let __v_79: G = __r_arr[16]; let __v_80: G = __r_arr[17]; let __v_81: G = __r_arr[18]; let __v_82: G = __r_arr[19]; let __v_83: G = __r_arr[20]; let __v_84: G = __r_arr[21]; let __v_85: G = __r_arr[22]; let __v_86: G = __r_arr[23]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, (&__args[..]))?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { (*(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225])) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = __r_arr[3]; let __v_91: G = __r_arr[4]; let __v_92: G = __r_arr[5]; let __v_93: G = __r_arr[6]; let __v_94: G = __r_arr[7]; let __v_95: G = __r_arr[8]; let __v_96: G = __r_arr[9]; let __v_97: G = __r_arr[10]; let __v_98: G = __r_arr[11]; let __v_99: G = __r_arr[12]; let __v_100: G = __r_arr[13]; let __v_101: G = __r_arr[14]; let __v_102: G = __r_arr[15]; let __v_103: G = __r_arr[16]; let __v_104: G = __r_arr[17]; let __v_105: G = __r_arr[18]; let __v_106: G = __r_arr[19]; let __v_107: G = __r_arr[20]; let __v_108: G = __r_arr[21]; let __v_109: G = __r_arr[22]; let __v_110: G = __r_arr[23]; let __v_111: G = (__v_25 * __v_64); let __v_112: G = (__v_27 * __v_65); let __v_113: G = (__v_29 * __v_66); let __v_114: G = (__v_31 * __v_67); let __v_115: G = (__v_33 * __v_68); let __v_116: G = (__v_35 * __v_69); let __v_117: G = (__v_37 * __v_70); let __v_118: G = (__v_116 + __v_117); let __v_119: G = (__v_115 + __v_118); let __v_120: G = (__v_114 + __v_119); let __v_121: G = (__v_113 + __v_120); let __v_122: G = (__v_112 + __v_121); let __v_123: G = (__v_111 + __v_122); let __v_124: G = (__v_63 + __v_123); let __v_125: G = G::from_u64(16); if (__v_124 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_124.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_126: G = (__v_25 * __v_88); let __v_127: G = (__v_27 * __v_89); let __v_128: G = (__v_29 * __v_90); let __v_129: G = (__v_31 * __v_91); let __v_130: G = (__v_33 * __v_92); let __v_131: G = (__v_35 * __v_93); let __v_132: G = (__v_37 * __v_94); let __v_133: G = (__v_131 + __v_132); let __v_134: G = (__v_130 + __v_133); let __v_135: G = (__v_129 + __v_134); let __v_136: G = (__v_128 + __v_135); let __v_137: G = (__v_127 + __v_136); let __v_138: G = (__v_126 + __v_137); let __v_139: G = (__v_87 + __v_138); if (__v_139 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_140: G = (__v_25 * __v_72); let __v_141: G = (__v_27 * __v_73); let __v_142: G = (__v_29 * __v_74); let __v_143: G = (__v_31 * __v_75); let __v_144: G = (__v_33 * __v_76); let __v_145: G = (__v_35 * __v_77); let __v_146: G = (__v_37 * __v_78); let __v_147: G = (__v_145 + __v_146); let __v_148: G = (__v_144 + __v_147); let __v_149: G = (__v_143 + __v_148); let __v_150: G = (__v_142 + __v_149); let __v_151: G = (__v_141 + __v_150); let __v_152: G = (__v_140 + __v_151); let __v_153: G = (__v_71 + __v_152); let __v_154: G = (__v_25 * __v_96); let __v_155: G = (__v_27 * __v_97); let __v_156: G = (__v_29 * __v_98); let __v_157: G = (__v_31 * __v_99); let __v_158: G = (__v_33 * __v_100); let __v_159: G = (__v_35 * __v_101); let __v_160: G = (__v_37 * __v_102); let __v_161: G = (__v_159 + __v_160); let __v_162: G = (__v_158 + __v_161); let __v_163: G = (__v_157 + __v_162); let __v_164: G = (__v_156 + __v_163); let __v_165: G = (__v_155 + __v_164); let __v_166: G = (__v_154 + __v_165); let __v_167: G = (__v_95 + __v_166); if (__v_167 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_168: G = (__v_25 * __v_80); let __v_169: G = (__v_27 * __v_81); let __v_170: G = (__v_29 * __v_82); let __v_171: G = (__v_31 * __v_83); let __v_172: G = (__v_33 * __v_84); let __v_173: G = (__v_35 * __v_85); let __v_174: G = (__v_37 * __v_86); let __v_175: G = (__v_173 + __v_174); let __v_176: G = (__v_172 + __v_175); let __v_177: G = (__v_171 + __v_176); let __v_178: G = (__v_170 + __v_177); let __v_179: G = (__v_169 + __v_178); let __v_180: G = (__v_168 + __v_179); let __v_181: G = (__v_79 + __v_180); let __v_182: G = (__v_25 * __v_104); let __v_183: G = (__v_27 * __v_105); let __v_184: G = (__v_29 * __v_106); let __v_185: G = (__v_31 * __v_107); let __v_186: G = (__v_33 * __v_108); let __v_187: G = (__v_35 * __v_109); let __v_188: G = (__v_37 * __v_110); let __v_189: G = (__v_187 + __v_188); let __v_190: G = (__v_186 + __v_189); let __v_191: G = (__v_185 + __v_190); let __v_192: G = (__v_184 + __v_191); let __v_193: G = (__v_183 + __v_192); let __v_194: G = (__v_182 + __v_193); let __v_195: G = (__v_103 + __v_194); let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_196: G = G::from_u8(__gb[0]); let __v_197: G = G::from_u8(__gb[1]); let __v_198: G = G::from_u8(__gb[2]); let __v_199: G = G::from_u8(__gb[3]); let __v_200: G = G::from_u8(__gb[4]); let __v_201: G = G::from_u8(__gb[5]); let __v_202: G = G::from_u8(__gb[6]); let __v_203: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_200; let __vj = __v_201; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_202; let __vj = __v_203; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_204: G = (__v_25 * __v_197); let __v_205: G = (__v_27 * __v_198); let __v_206: G = (__v_29 * __v_199); let __v_207: G = (__v_31 * __v_200); let __v_208: G = (__v_33 * __v_201); let __v_209: G = (__v_35 * __v_202); let __v_210: G = (__v_37 * __v_203); let __v_211: G = (__v_209 + __v_210); let __v_212: G = (__v_208 + __v_211); let __v_213: G = (__v_207 + __v_212); let __v_214: G = (__v_206 + __v_213); let __v_215: G = (__v_205 + __v_214); let __v_216: G = (__v_204 + __v_215); let __v_217: G = (__v_196 + __v_216); if (__v_217 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_218: G = G::from_u64(1020); let __v_219: G = (__v_203 - __v_218); let __v_220: G = (__v_202 + __v_219); let __v_221: G = (__v_201 + __v_220); let __v_222: G = (__v_200 + __v_221); let __v_223: G = G::from_bool((__v_222 == G::ZERO)); let __v_224: G = (__v_198 + __v_199); let __v_225: G = (__v_197 + __v_224); let __v_226: G = (__v_196 + __v_225); let __v_227: G = G::from_bool((__v_226 == G::ZERO)); let __v_228: G = (__v_46 - __v_227); let __v_229: G = (__v_223 * __v_228); let __v_230: G = (__v_46 - __v_229); if (__v_230 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_195.as_canonical_u64().to_le_bytes(); let __v_231: G = G::from_u8(__gb[0]); let __v_232: G = G::from_u8(__gb[1]); let __v_233: G = G::from_u8(__gb[2]); let __v_234: G = G::from_u8(__gb[3]); let __v_235: G = G::from_u8(__gb[4]); let __v_236: G = G::from_u8(__gb[5]); let __v_237: G = G::from_u8(__gb[6]); let __v_238: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_235; let __vj = __v_236; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_239: G = (__v_25 * __v_232); let __v_240: G = (__v_27 * __v_233); let __v_241: G = (__v_29 * __v_234); let __v_242: G = (__v_31 * __v_235); let __v_243: G = (__v_33 * __v_236); let __v_244: G = (__v_35 * __v_237); let __v_245: G = (__v_37 * __v_238); let __v_246: G = (__v_244 + __v_245); let __v_247: G = (__v_243 + __v_246); let __v_248: G = (__v_242 + __v_247); let __v_249: G = (__v_241 + __v_248); let __v_250: G = (__v_240 + __v_249); let __v_251: G = (__v_239 + __v_250); let __v_252: G = (__v_231 + __v_251); if (__v_252 != __v_195) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_195.as_canonical_u64(), msg: None }); } let __v_253: G = (__v_238 - __v_218); let __v_254: G = (__v_237 + __v_253); let __v_255: G = (__v_236 + __v_254); let __v_256: G = (__v_235 + __v_255); let __v_257: G = G::from_bool((__v_256 == G::ZERO)); let __v_258: G = (__v_233 + __v_234); let __v_259: G = (__v_232 + __v_258); let __v_260: G = (__v_231 + __v_259); let __v_261: G = G::from_bool((__v_260 == G::ZERO)); let __v_262: G = (__v_46 - __v_261); let __v_263: G = (__v_257 * __v_262); let __v_264: G = (__v_46 - __v_263); if (__v_264 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_265: G = __r_arr[0]; if (__v_265 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_265.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_266: G = (__v_153 - __v_1); let __v_267: G = G::from_bool((__v_266 == G::ZERO)); let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_268: G = G::from_u8(__gb[0]); let __v_269: G = G::from_u8(__gb[1]); let __v_270: G = G::from_u8(__gb[2]); let __v_271: G = G::from_u8(__gb[3]); let __v_272: G = G::from_u8(__gb[4]); let __v_273: G = G::from_u8(__gb[5]); let __v_274: G = G::from_u8(__gb[6]); let __v_275: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_272; let __vj = __v_273; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_274; let __vj = __v_275; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_276: G = (__v_25 * __v_269); let __v_277: G = (__v_27 * __v_270); let __v_278: G = (__v_29 * __v_271); let __v_279: G = (__v_31 * __v_272); let __v_280: G = (__v_33 * __v_273); let __v_281: G = (__v_35 * __v_274); let __v_282: G = (__v_37 * __v_275); let __v_283: G = (__v_281 + __v_282); let __v_284: G = (__v_280 + __v_283); let __v_285: G = (__v_279 + __v_284); let __v_286: G = (__v_278 + __v_285); let __v_287: G = (__v_277 + __v_286); let __v_288: G = (__v_276 + __v_287); let __v_289: G = (__v_268 + __v_288); if (__v_289 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_289.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_290: G = (__v_275 - __v_218); let __v_291: G = (__v_274 + __v_290); let __v_292: G = (__v_273 + __v_291); let __v_293: G = (__v_272 + __v_292); let __v_294: G = G::from_bool((__v_293 == G::ZERO)); let __v_295: G = (__v_270 + __v_271); let __v_296: G = (__v_269 + __v_295); let __v_297: G = (__v_268 + __v_296); let __v_298: G = G::from_bool((__v_297 == G::ZERO)); let __v_299: G = (__v_46 - __v_298); let __v_300: G = (__v_294 * __v_299); let __v_301: G = (__v_46 - __v_300); if (__v_301 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_301.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_302: G = G::from_u8(__gb[0]); let __v_303: G = G::from_u8(__gb[1]); let __v_304: G = G::from_u8(__gb[2]); let __v_305: G = G::from_u8(__gb[3]); let __v_306: G = G::from_u8(__gb[4]); let __v_307: G = G::from_u8(__gb[5]); let __v_308: G = G::from_u8(__gb[6]); let __v_309: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_304; let __vj = __v_305; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_306; let __vj = __v_307; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_308; let __vj = __v_309; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_310: G = (__v_25 * __v_303); let __v_311: G = (__v_27 * __v_304); let __v_312: G = (__v_29 * __v_305); let __v_313: G = (__v_31 * __v_306); let __v_314: G = (__v_33 * __v_307); let __v_315: G = (__v_35 * __v_308); let __v_316: G = (__v_37 * __v_309); let __v_317: G = (__v_315 + __v_316); let __v_318: G = (__v_314 + __v_317); let __v_319: G = (__v_313 + __v_318); let __v_320: G = (__v_312 + __v_319); let __v_321: G = (__v_311 + __v_320); let __v_322: G = (__v_310 + __v_321); let __v_323: G = (__v_302 + __v_322); if (__v_323 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_323.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_324: G = (__v_309 - __v_218); let __v_325: G = (__v_308 + __v_324); let __v_326: G = (__v_307 + __v_325); let __v_327: G = (__v_306 + __v_326); let __v_328: G = G::from_bool((__v_327 == G::ZERO)); let __v_329: G = (__v_304 + __v_305); let __v_330: G = (__v_303 + __v_329); let __v_331: G = (__v_302 + __v_330); let __v_332: G = G::from_bool((__v_331 == G::ZERO)); let __v_333: G = (__v_46 - __v_332); let __v_334: G = (__v_328 * __v_333); let __v_335: G = (__v_46 - __v_334); if (__v_335 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_336: G = __r_arr[0]; let __v_337: G = (__v_46 - __v_336); let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_338: G = G::from_u8(__gb[0]); let __v_339: G = G::from_u8(__gb[1]); let __v_340: G = G::from_u8(__gb[2]); let __v_341: G = G::from_u8(__gb[3]); let __v_342: G = G::from_u8(__gb[4]); let __v_343: G = G::from_u8(__gb[5]); let __v_344: G = G::from_u8(__gb[6]); let __v_345: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_338; let __vj = __v_339; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_340; let __vj = __v_341; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_342; let __vj = __v_343; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_344; let __vj = __v_345; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_346: G = (__v_25 * __v_339); let __v_347: G = (__v_27 * __v_340); let __v_348: G = (__v_29 * __v_341); let __v_349: G = (__v_31 * __v_342); let __v_350: G = (__v_33 * __v_343); let __v_351: G = (__v_35 * __v_344); let __v_352: G = (__v_37 * __v_345); let __v_353: G = (__v_351 + __v_352); let __v_354: G = (__v_350 + __v_353); let __v_355: G = (__v_349 + __v_354); let __v_356: G = (__v_348 + __v_355); let __v_357: G = (__v_347 + __v_356); let __v_358: G = (__v_346 + __v_357); let __v_359: G = (__v_338 + __v_358); if (__v_359 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_360: G = (__v_345 - __v_218); let __v_361: G = (__v_344 + __v_360); let __v_362: G = (__v_343 + __v_361); let __v_363: G = (__v_342 + __v_362); let __v_364: G = G::from_bool((__v_363 == G::ZERO)); let __v_365: G = (__v_340 + __v_341); let __v_366: G = (__v_339 + __v_365); let __v_367: G = (__v_338 + __v_366); let __v_368: G = G::from_bool((__v_367 == G::ZERO)); let __v_369: G = (__v_46 - __v_368); let __v_370: G = (__v_364 * __v_369); let __v_371: G = (__v_46 - __v_370); if (__v_371 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_372: G = G::from_u8(__gb[0]); let __v_373: G = G::from_u8(__gb[1]); let __v_374: G = G::from_u8(__gb[2]); let __v_375: G = G::from_u8(__gb[3]); let __v_376: G = G::from_u8(__gb[4]); let __v_377: G = G::from_u8(__gb[5]); let __v_378: G = G::from_u8(__gb[6]); let __v_379: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_372; let __vj = __v_373; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_374; let __vj = __v_375; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_376; let __vj = __v_377; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } if (!unconstrained) { let __vi = __v_378; let __vj = __v_379; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check((&__vi), (&__vj)); } let __v_380: G = (__v_25 * __v_373); let __v_381: G = (__v_27 * __v_374); let __v_382: G = (__v_29 * __v_375); let __v_383: G = (__v_31 * __v_376); let __v_384: G = (__v_33 * __v_377); let __v_385: G = (__v_35 * __v_378); let __v_386: G = (__v_37 * __v_379); let __v_387: G = (__v_385 + __v_386); let __v_388: G = (__v_384 + __v_387); let __v_389: G = (__v_383 + __v_388); let __v_390: G = (__v_382 + __v_389); let __v_391: G = (__v_381 + __v_390); let __v_392: G = (__v_380 + __v_391); let __v_393: G = (__v_372 + __v_392); if (__v_393 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_393.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_394: G = (__v_379 - __v_218); let __v_395: G = (__v_378 + __v_394); let __v_396: G = (__v_377 + __v_395); let __v_397: G = (__v_376 + __v_396); let __v_398: G = G::from_bool((__v_397 == G::ZERO)); let __v_399: G = (__v_374 + __v_375); let __v_400: G = (__v_373 + __v_399); let __v_401: G = (__v_372 + __v_400); let __v_402: G = G::from_bool((__v_401 == G::ZERO)); let __v_403: G = (__v_46 - __v_402); let __v_404: G = (__v_398 * __v_403); let __v_405: G = (__v_46 - __v_404); if (__v_405 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, (&__args[..]))?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { (*(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227])) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_406: G = __r_arr[0]; let __v_407: G = (__v_267 * __v_406); let __v_408: G = (__v_337 + __v_407); if (__v_408 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, (&__args[..]))?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { (*(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228])) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_228] = [__v_409]; record.function_queries[228].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_228(inp: [G; IN_228], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_228] = [__v_14]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = __loaded[6]; let __v_21: G = __loaded[7]; let __v_22: G = __loaded[8]; let __v_23: G = __loaded[9]; let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { _ => { let __v_25: G = G::from_u64(256); let __v_26: G = __v_25 * __v_6; let __v_27: G = G::from_u64(65536); let __v_28: G = __v_27 * __v_7; let __v_29: G = G::from_u64(16777216); let __v_30: G = __v_29 * __v_8; let __v_31: G = G::from_u64(4294967296); let __v_32: G = __v_31 * __v_9; let __v_33: G = G::from_u64(1099511627776); let __v_34: G = __v_33 * __v_10; let __v_35: G = G::from_u64(281474976710656); let __v_36: G = __v_35 * __v_11; let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = __v_37 * __v_12; let __v_39: G = __v_36 + __v_38; let __v_40: G = __v_34 + __v_39; let __v_41: G = __v_32 + __v_40; let __v_42: G = __v_30 + __v_41; let __v_43: G = __v_28 + __v_42; let __v_44: G = __v_26 + __v_43; let __v_45: G = __v_5 + __v_44; let __v_46: G = G::from_u64(1); let __v_47: G = __v_45 + __v_46; let __v_48: G = G::from_u64(0); if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __v_49: G = __v_25 * __v_17; let __v_50: G = __v_27 * __v_18; let __v_51: G = __v_29 * __v_19; let __v_52: G = __v_31 * __v_20; let __v_53: G = __v_33 * __v_21; let __v_54: G = __v_35 * __v_22; let __v_55: G = __v_37 * __v_23; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_53 + __v_56; let __v_58: G = __v_52 + __v_57; let __v_59: G = __v_51 + __v_58; let __v_60: G = __v_50 + __v_59; let __v_61: G = __v_49 + __v_60; let __v_62: G = __v_16 + __v_61; if (__v_62 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, &__args[..])?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; let __v_66: G = __r_arr[3]; let __v_67: G = __r_arr[4]; let __v_68: G = __r_arr[5]; let __v_69: G = __r_arr[6]; let __v_70: G = __r_arr[7]; let __v_71: G = __r_arr[8]; let __v_72: G = __r_arr[9]; let __v_73: G = __r_arr[10]; let __v_74: G = __r_arr[11]; let __v_75: G = __r_arr[12]; let __v_76: G = __r_arr[13]; let __v_77: G = __r_arr[14]; let __v_78: G = __r_arr[15]; let __v_79: G = __r_arr[16]; let __v_80: G = __r_arr[17]; let __v_81: G = __r_arr[18]; let __v_82: G = __r_arr[19]; let __v_83: G = __r_arr[20]; let __v_84: G = __r_arr[21]; let __v_85: G = __r_arr[22]; let __v_86: G = __r_arr[23]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(225, &__args[..])?) { [G::ZERO; OUT_225] } else { let (__hash, __hit) = record.function_queries[225].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[225].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => { aiur_fn_225::(__args, __hash, record, io_buffer)? }, } } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = __r_arr[3]; let __v_91: G = __r_arr[4]; let __v_92: G = __r_arr[5]; let __v_93: G = __r_arr[6]; let __v_94: G = __r_arr[7]; let __v_95: G = __r_arr[8]; let __v_96: G = __r_arr[9]; let __v_97: G = __r_arr[10]; let __v_98: G = __r_arr[11]; let __v_99: G = __r_arr[12]; let __v_100: G = __r_arr[13]; let __v_101: G = __r_arr[14]; let __v_102: G = __r_arr[15]; let __v_103: G = __r_arr[16]; let __v_104: G = __r_arr[17]; let __v_105: G = __r_arr[18]; let __v_106: G = __r_arr[19]; let __v_107: G = __r_arr[20]; let __v_108: G = __r_arr[21]; let __v_109: G = __r_arr[22]; let __v_110: G = __r_arr[23]; let __v_111: G = __v_25 * __v_64; let __v_112: G = __v_27 * __v_65; let __v_113: G = __v_29 * __v_66; let __v_114: G = __v_31 * __v_67; let __v_115: G = __v_33 * __v_68; let __v_116: G = __v_35 * __v_69; let __v_117: G = __v_37 * __v_70; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_115 + __v_118; let __v_120: G = __v_114 + __v_119; let __v_121: G = __v_113 + __v_120; let __v_122: G = __v_112 + __v_121; let __v_123: G = __v_111 + __v_122; let __v_124: G = __v_63 + __v_123; let __v_125: G = G::from_u64(16); if (__v_124 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_124.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_126: G = __v_25 * __v_88; let __v_127: G = __v_27 * __v_89; let __v_128: G = __v_29 * __v_90; let __v_129: G = __v_31 * __v_91; let __v_130: G = __v_33 * __v_92; let __v_131: G = __v_35 * __v_93; let __v_132: G = __v_37 * __v_94; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_130 + __v_133; let __v_135: G = __v_129 + __v_134; let __v_136: G = __v_128 + __v_135; let __v_137: G = __v_127 + __v_136; let __v_138: G = __v_126 + __v_137; let __v_139: G = __v_87 + __v_138; if (__v_139 != __v_125) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_125.as_canonical_u64(), msg: None }); } let __v_140: G = __v_25 * __v_72; let __v_141: G = __v_27 * __v_73; let __v_142: G = __v_29 * __v_74; let __v_143: G = __v_31 * __v_75; let __v_144: G = __v_33 * __v_76; let __v_145: G = __v_35 * __v_77; let __v_146: G = __v_37 * __v_78; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_144 + __v_147; let __v_149: G = __v_143 + __v_148; let __v_150: G = __v_142 + __v_149; let __v_151: G = __v_141 + __v_150; let __v_152: G = __v_140 + __v_151; let __v_153: G = __v_71 + __v_152; let __v_154: G = __v_25 * __v_96; let __v_155: G = __v_27 * __v_97; let __v_156: G = __v_29 * __v_98; let __v_157: G = __v_31 * __v_99; let __v_158: G = __v_33 * __v_100; let __v_159: G = __v_35 * __v_101; let __v_160: G = __v_37 * __v_102; let __v_161: G = __v_159 + __v_160; let __v_162: G = __v_158 + __v_161; let __v_163: G = __v_157 + __v_162; let __v_164: G = __v_156 + __v_163; let __v_165: G = __v_155 + __v_164; let __v_166: G = __v_154 + __v_165; let __v_167: G = __v_95 + __v_166; if (__v_167 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_168: G = __v_25 * __v_80; let __v_169: G = __v_27 * __v_81; let __v_170: G = __v_29 * __v_82; let __v_171: G = __v_31 * __v_83; let __v_172: G = __v_33 * __v_84; let __v_173: G = __v_35 * __v_85; let __v_174: G = __v_37 * __v_86; let __v_175: G = __v_173 + __v_174; let __v_176: G = __v_172 + __v_175; let __v_177: G = __v_171 + __v_176; let __v_178: G = __v_170 + __v_177; let __v_179: G = __v_169 + __v_178; let __v_180: G = __v_168 + __v_179; let __v_181: G = __v_79 + __v_180; let __v_182: G = __v_25 * __v_104; let __v_183: G = __v_27 * __v_105; let __v_184: G = __v_29 * __v_106; let __v_185: G = __v_31 * __v_107; let __v_186: G = __v_33 * __v_108; let __v_187: G = __v_35 * __v_109; let __v_188: G = __v_37 * __v_110; let __v_189: G = __v_187 + __v_188; let __v_190: G = __v_186 + __v_189; let __v_191: G = __v_185 + __v_190; let __v_192: G = __v_184 + __v_191; let __v_193: G = __v_183 + __v_192; let __v_194: G = __v_182 + __v_193; let __v_195: G = __v_103 + __v_194; let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_196: G = G::from_u8(__gb[0]); let __v_197: G = G::from_u8(__gb[1]); let __v_198: G = G::from_u8(__gb[2]); let __v_199: G = G::from_u8(__gb[3]); let __v_200: G = G::from_u8(__gb[4]); let __v_201: G = G::from_u8(__gb[5]); let __v_202: G = G::from_u8(__gb[6]); let __v_203: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_200; let __vj = __v_201; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_202; let __vj = __v_203; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_204: G = __v_25 * __v_197; let __v_205: G = __v_27 * __v_198; let __v_206: G = __v_29 * __v_199; let __v_207: G = __v_31 * __v_200; let __v_208: G = __v_33 * __v_201; let __v_209: G = __v_35 * __v_202; let __v_210: G = __v_37 * __v_203; let __v_211: G = __v_209 + __v_210; let __v_212: G = __v_208 + __v_211; let __v_213: G = __v_207 + __v_212; let __v_214: G = __v_206 + __v_213; let __v_215: G = __v_205 + __v_214; let __v_216: G = __v_204 + __v_215; let __v_217: G = __v_196 + __v_216; if (__v_217 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_218: G = G::from_u64(1020); let __v_219: G = __v_203 - __v_218; let __v_220: G = __v_202 + __v_219; let __v_221: G = __v_201 + __v_220; let __v_222: G = __v_200 + __v_221; let __v_223: G = G::from_bool(__v_222 == G::ZERO); let __v_224: G = __v_198 + __v_199; let __v_225: G = __v_197 + __v_224; let __v_226: G = __v_196 + __v_225; let __v_227: G = G::from_bool(__v_226 == G::ZERO); let __v_228: G = __v_46 - __v_227; let __v_229: G = __v_223 * __v_228; let __v_230: G = __v_46 - __v_229; if (__v_230 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_195.as_canonical_u64().to_le_bytes(); let __v_231: G = G::from_u8(__gb[0]); let __v_232: G = G::from_u8(__gb[1]); let __v_233: G = G::from_u8(__gb[2]); let __v_234: G = G::from_u8(__gb[3]); let __v_235: G = G::from_u8(__gb[4]); let __v_236: G = G::from_u8(__gb[5]); let __v_237: G = G::from_u8(__gb[6]); let __v_238: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_235; let __vj = __v_236; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_237; let __vj = __v_238; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_239: G = __v_25 * __v_232; let __v_240: G = __v_27 * __v_233; let __v_241: G = __v_29 * __v_234; let __v_242: G = __v_31 * __v_235; let __v_243: G = __v_33 * __v_236; let __v_244: G = __v_35 * __v_237; let __v_245: G = __v_37 * __v_238; let __v_246: G = __v_244 + __v_245; let __v_247: G = __v_243 + __v_246; let __v_248: G = __v_242 + __v_247; let __v_249: G = __v_241 + __v_248; let __v_250: G = __v_240 + __v_249; let __v_251: G = __v_239 + __v_250; let __v_252: G = __v_231 + __v_251; if (__v_252 != __v_195) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_195.as_canonical_u64(), msg: None }); } let __v_253: G = __v_238 - __v_218; let __v_254: G = __v_237 + __v_253; let __v_255: G = __v_236 + __v_254; let __v_256: G = __v_235 + __v_255; let __v_257: G = G::from_bool(__v_256 == G::ZERO); let __v_258: G = __v_233 + __v_234; let __v_259: G = __v_232 + __v_258; let __v_260: G = __v_231 + __v_259; let __v_261: G = G::from_bool(__v_260 == G::ZERO); let __v_262: G = __v_46 - __v_261; let __v_263: G = __v_257 * __v_262; let __v_264: G = __v_46 - __v_263; if (__v_264 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_264.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_265: G = __r_arr[0]; if (__v_265 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_265.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_266: G = __v_153 - __v_1; let __v_267: G = G::from_bool(__v_266 == G::ZERO); let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_268: G = G::from_u8(__gb[0]); let __v_269: G = G::from_u8(__gb[1]); let __v_270: G = G::from_u8(__gb[2]); let __v_271: G = G::from_u8(__gb[3]); let __v_272: G = G::from_u8(__gb[4]); let __v_273: G = G::from_u8(__gb[5]); let __v_274: G = G::from_u8(__gb[6]); let __v_275: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_268; let __vj = __v_269; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_270; let __vj = __v_271; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_272; let __vj = __v_273; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_274; let __vj = __v_275; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_276: G = __v_25 * __v_269; let __v_277: G = __v_27 * __v_270; let __v_278: G = __v_29 * __v_271; let __v_279: G = __v_31 * __v_272; let __v_280: G = __v_33 * __v_273; let __v_281: G = __v_35 * __v_274; let __v_282: G = __v_37 * __v_275; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_280 + __v_283; let __v_285: G = __v_279 + __v_284; let __v_286: G = __v_278 + __v_285; let __v_287: G = __v_277 + __v_286; let __v_288: G = __v_276 + __v_287; let __v_289: G = __v_268 + __v_288; if (__v_289 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_289.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: None }); } let __v_290: G = __v_275 - __v_218; let __v_291: G = __v_274 + __v_290; let __v_292: G = __v_273 + __v_291; let __v_293: G = __v_272 + __v_292; let __v_294: G = G::from_bool(__v_293 == G::ZERO); let __v_295: G = __v_270 + __v_271; let __v_296: G = __v_269 + __v_295; let __v_297: G = __v_268 + __v_296; let __v_298: G = G::from_bool(__v_297 == G::ZERO); let __v_299: G = __v_46 - __v_298; let __v_300: G = __v_294 * __v_299; let __v_301: G = __v_46 - __v_300; if (__v_301 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_301.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes(); let __v_302: G = G::from_u8(__gb[0]); let __v_303: G = G::from_u8(__gb[1]); let __v_304: G = G::from_u8(__gb[2]); let __v_305: G = G::from_u8(__gb[3]); let __v_306: G = G::from_u8(__gb[4]); let __v_307: G = G::from_u8(__gb[5]); let __v_308: G = G::from_u8(__gb[6]); let __v_309: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_302; let __vj = __v_303; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_304; let __vj = __v_305; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_306; let __vj = __v_307; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_308; let __vj = __v_309; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_310: G = __v_25 * __v_303; let __v_311: G = __v_27 * __v_304; let __v_312: G = __v_29 * __v_305; let __v_313: G = __v_31 * __v_306; let __v_314: G = __v_33 * __v_307; let __v_315: G = __v_35 * __v_308; let __v_316: G = __v_37 * __v_309; let __v_317: G = __v_315 + __v_316; let __v_318: G = __v_314 + __v_317; let __v_319: G = __v_313 + __v_318; let __v_320: G = __v_312 + __v_319; let __v_321: G = __v_311 + __v_320; let __v_322: G = __v_310 + __v_321; let __v_323: G = __v_302 + __v_322; if (__v_323 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_323.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } let __v_324: G = __v_309 - __v_218; let __v_325: G = __v_308 + __v_324; let __v_326: G = __v_307 + __v_325; let __v_327: G = __v_306 + __v_326; let __v_328: G = G::from_bool(__v_327 == G::ZERO); let __v_329: G = __v_304 + __v_305; let __v_330: G = __v_303 + __v_329; let __v_331: G = __v_302 + __v_330; let __v_332: G = G::from_bool(__v_331 == G::ZERO); let __v_333: G = __v_46 - __v_332; let __v_334: G = __v_328 * __v_333; let __v_335: G = __v_46 - __v_334; if (__v_335 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_336: G = __r_arr[0]; let __v_337: G = __v_46 - __v_336; let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes(); let __v_338: G = G::from_u8(__gb[0]); let __v_339: G = G::from_u8(__gb[1]); let __v_340: G = G::from_u8(__gb[2]); let __v_341: G = G::from_u8(__gb[3]); let __v_342: G = G::from_u8(__gb[4]); let __v_343: G = G::from_u8(__gb[5]); let __v_344: G = G::from_u8(__gb[6]); let __v_345: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_338; let __vj = __v_339; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_340; let __vj = __v_341; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_342; let __vj = __v_343; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_344; let __vj = __v_345; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_346: G = __v_25 * __v_339; let __v_347: G = __v_27 * __v_340; let __v_348: G = __v_29 * __v_341; let __v_349: G = __v_31 * __v_342; let __v_350: G = __v_33 * __v_343; let __v_351: G = __v_35 * __v_344; let __v_352: G = __v_37 * __v_345; let __v_353: G = __v_351 + __v_352; let __v_354: G = __v_350 + __v_353; let __v_355: G = __v_349 + __v_354; let __v_356: G = __v_348 + __v_355; let __v_357: G = __v_347 + __v_356; let __v_358: G = __v_346 + __v_357; let __v_359: G = __v_338 + __v_358; if (__v_359 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __v_360: G = __v_345 - __v_218; let __v_361: G = __v_344 + __v_360; let __v_362: G = __v_343 + __v_361; let __v_363: G = __v_342 + __v_362; let __v_364: G = G::from_bool(__v_363 == G::ZERO); let __v_365: G = __v_340 + __v_341; let __v_366: G = __v_339 + __v_365; let __v_367: G = __v_338 + __v_366; let __v_368: G = G::from_bool(__v_367 == G::ZERO); let __v_369: G = __v_46 - __v_368; let __v_370: G = __v_364 * __v_369; let __v_371: G = __v_46 - __v_370; if (__v_371 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __gb: [u8; 8] = __v_181.as_canonical_u64().to_le_bytes(); let __v_372: G = G::from_u8(__gb[0]); let __v_373: G = G::from_u8(__gb[1]); let __v_374: G = G::from_u8(__gb[2]); let __v_375: G = G::from_u8(__gb[3]); let __v_376: G = G::from_u8(__gb[4]); let __v_377: G = G::from_u8(__gb[5]); let __v_378: G = G::from_u8(__gb[6]); let __v_379: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_372; let __vj = __v_373; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_374; let __vj = __v_375; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_376; let __vj = __v_377; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_378; let __vj = __v_379; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_380: G = __v_25 * __v_373; let __v_381: G = __v_27 * __v_374; let __v_382: G = __v_29 * __v_375; let __v_383: G = __v_31 * __v_376; let __v_384: G = __v_33 * __v_377; let __v_385: G = __v_35 * __v_378; let __v_386: G = __v_37 * __v_379; let __v_387: G = __v_385 + __v_386; let __v_388: G = __v_384 + __v_387; let __v_389: G = __v_383 + __v_388; let __v_390: G = __v_382 + __v_389; let __v_391: G = __v_381 + __v_390; let __v_392: G = __v_380 + __v_391; let __v_393: G = __v_372 + __v_392; if (__v_393 != __v_181) { return Err(ExecError::AssertEqMismatch { lhs: __v_393.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: None }); } let __v_394: G = __v_379 - __v_218; let __v_395: G = __v_378 + __v_394; let __v_396: G = __v_377 + __v_395; let __v_397: G = __v_376 + __v_396; let __v_398: G = G::from_bool(__v_397 == G::ZERO); let __v_399: G = __v_374 + __v_375; let __v_400: G = __v_373 + __v_399; let __v_401: G = __v_372 + __v_400; let __v_402: G = G::from_bool(__v_401 == G::ZERO); let __v_403: G = __v_46 - __v_402; let __v_404: G = __v_398 * __v_403; let __v_405: G = __v_46 - __v_404; if (__v_405 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_378, __v_379]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(227, &__args[..])?) { [G::ZERO; OUT_227] } else { let (__hash, __hit) = record.function_queries[227].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[227].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => { aiur_fn_227::(__args, __hash, record, io_buffer)? }, } } }; let __v_406: G = __r_arr[0]; let __v_407: G = __v_267 * __v_406; let __v_408: G = __v_337 + __v_407; if (__v_408 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, &__args[..])?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_228] = [__v_409]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_229: usize = 46; const IN_229: usize = 46; const OUT_229: usize = 2; -fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { let __v_46: G = G::from_u64(0); if (__v_1 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } if (__v_2 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_47: G = G::from_u64(1); if (__v_3 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None }); } match __v_12.as_canonical_u64() { _ => { match __v_17.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_bool((__v_48 == G::ZERO)); let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; if (__v_51 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; if (__v_52 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; if (__v_53 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, (&__args[..]))?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { (*(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203])) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = (__v_56 - __v_57); let __v_59: G = G::from_bool((__v_58 == G::ZERO)); if (__v_59 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, (&__args[..]))?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { (*(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204])) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, (&__args[..]))?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { (*(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205])) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_62 - __v_63); let __v_65: G = G::from_bool((__v_64 == G::ZERO)); if (__v_65 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = G::from_u64(1); if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_13, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, (&__args[..]))?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { (*(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218])) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; if (__v_68 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, (&__args[..]))?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { (*(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215])) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; if (__v_69 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, (&__args[..]))?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { (*(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222])) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, (&__args[..]))?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { (*(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223])) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_71 != __v_72) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None }); } let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_73, __v_73, __v_73]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_74]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_16, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(214, (&__args[..]))?) { [G::ZERO; OUT_214] } else { let (__hash, __hit) = record.function_queries[214].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[214].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { (*(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214])) }; __ret }, _ => { aiur_fn_214::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = G::from_u64(0); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, (&__args[..]))?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { (*(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202])) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_60, __v_61, __v_22, __v_21, __v_39, __v_40, __v_37, __v_38, __v_36, __v_79, __v_80, __v_81, __v_42, __v_43, __v_44, __v_45, __v_74, __v_75, __v_76, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, (&__args[..]))?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { (*(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200])) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __v_86: G = (__v_85 - __v_84); let __v_87: G = G::from_bool((__v_86 == G::ZERO)); let __v_88: G = G::from_u64(1); if (__v_87 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, (&__args[..]))?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { (*(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142])) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = (__v_90 + __v_91); if (__v_89 != __v_92) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = (__v_93 - __v_84); let __v_95: G = G::from_bool((__v_94 == G::ZERO)); if (__v_95 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_96 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __v_97: G = { let __values: [G; 3] = [__v_88, __v_88, __v_88]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_37.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_97]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_38, __v_97]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; break '__mc_1 [__v_98]; }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }; let __v_98: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_36, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_40, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_39, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, (&__args[..]))?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { (*(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133])) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_78, __v_101]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_102: G = __r_arr[0]; let __v_103: G = G::from_u64(1); let __v_104: G = { let __values: [G; 3] = [__v_103, __v_103, __v_103]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_102, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, (&__args[..]))?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { (*(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174])) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; let __v_108: G = __r_arr[3]; let __v_109: G = __r_arr[4]; let __v_110: G = __r_arr[5]; let __v_111: G = __r_arr[6]; let __v_112: G = __r_arr[7]; let __v_113: G = __r_arr[8]; let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = __r_arr[12]; let __v_118: G = __r_arr[13]; let __v_119: G = __r_arr[14]; let __v_120: G = __r_arr[15]; let __v_121: G = __r_arr[16]; let __v_122: G = __r_arr[17]; let __v_123: G = G::from_u64(256); let __v_124: G = (__v_123 * __v_106); let __v_125: G = G::from_u64(65536); let __v_126: G = (__v_125 * __v_107); let __v_127: G = G::from_u64(16777216); let __v_128: G = (__v_127 * __v_108); let __v_129: G = G::from_u64(4294967296); let __v_130: G = (__v_129 * __v_109); let __v_131: G = G::from_u64(1099511627776); let __v_132: G = (__v_131 * __v_110); let __v_133: G = G::from_u64(281474976710656); let __v_134: G = (__v_133 * __v_111); let __v_135: G = G::from_u64(72057594037927936); let __v_136: G = (__v_135 * __v_112); let __v_137: G = (__v_134 + __v_136); let __v_138: G = (__v_132 + __v_137); let __v_139: G = (__v_130 + __v_138); let __v_140: G = (__v_128 + __v_139); let __v_141: G = (__v_126 + __v_140); let __v_142: G = (__v_124 + __v_141); let __v_143: G = (__v_105 + __v_142); let __v_144: G = (__v_123 * __v_114); let __v_145: G = (__v_125 * __v_115); let __v_146: G = (__v_127 * __v_116); let __v_147: G = (__v_129 * __v_117); let __v_148: G = (__v_131 * __v_118); let __v_149: G = (__v_133 * __v_119); let __v_150: G = (__v_135 * __v_120); let __v_151: G = (__v_149 + __v_150); let __v_152: G = (__v_148 + __v_151); let __v_153: G = (__v_147 + __v_152); let __v_154: G = (__v_146 + __v_153); let __v_155: G = (__v_145 + __v_154); let __v_156: G = (__v_144 + __v_155); let __v_157: G = (__v_113 + __v_156); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_121, __v_23, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, (&__args[..]))?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { (*(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137])) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, (&__args[..]))?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { (*(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131])) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_159, __v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_161: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_161, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, (&__args[..]))?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { (*(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135])) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_162, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, (&__args[..]))?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { (*(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136])) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = (__v_84 + __v_0); let __v_166: G = G::from_u64(33); let __v_167: G = { let __a_val = __v_165.as_canonical_u64(); let __b_val = __v_166.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool((__a_u32 < __b_u32)); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check(((__word & 65535) as u16)); record.bytes2_queries.bump_u16_range_check(((__word >> 16) as u16)); } } __result }; if (__v_167 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_163, __v_164, __v_4, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, (&__args[..]))?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { (*(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158])) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_25, __v_168, __v_18, __v_19, __v_20, __v_73, __v_37, __v_38, __v_61, __v_22, __v_83, __v_0, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, (&__args[..]))?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { (*(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162])) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; if (__v_169 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, (&__args[..]))?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { (*(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161])) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_163, __v_164, __v_171, __v_143, __v_157, __v_39, __v_40, __v_36, __v_37, __v_38, __v_18, __v_19, __v_20, __v_73, __v_61, __v_22, __v_76, __v_77, __v_83, __v_0, __v_165, __v_158, __v_23, __v_27, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, (&__args[..]))?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { (*(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157])) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, (&__args[..]))?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { (*(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165])) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_173: G = __r_arr[0]; if (__v_173 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, (&__args[..]))?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { (*(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219])) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_229] = [__v_174, __v_175]; record.function_queries[229].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } +fn aiur_fn_229(inp: [G; IN_229], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { let __v_46: G = G::from_u64(0); if (__v_1 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } if (__v_2 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None }); } let __v_47: G = G::from_u64(1); if (__v_3 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None }); } match __v_12.as_canonical_u64() { _ => { match __v_17.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_bool(__v_48 == G::ZERO); let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; if (__v_51 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; if (__v_52 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; if (__v_53 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(203, &__args[..])?) { [G::ZERO; OUT_203] } else { let (__hash, __hit) = record.function_queries[203].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[203].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => { aiur_fn_203::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __v_56 - __v_57; let __v_59: G = G::from_bool(__v_58 == G::ZERO); if (__v_59 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(204, &__args[..])?) { [G::ZERO; OUT_204] } else { let (__hash, __hit) = record.function_queries[204].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[204].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => { aiur_fn_204::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(205, &__args[..])?) { [G::ZERO; OUT_205] } else { let (__hash, __hit) = record.function_queries[205].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[205].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => { aiur_fn_205::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = __v_62 - __v_63; let __v_65: G = G::from_bool(__v_64 == G::ZERO); if (__v_65 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None }); } match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = G::from_u64(1); if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_13, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(218, &__args[..])?) { [G::ZERO; OUT_218] } else { let (__hash, __hit) = record.function_queries[218].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[218].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => { aiur_fn_218::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; if (__v_68 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_14, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(215, &__args[..])?) { [G::ZERO; OUT_215] } else { let (__hash, __hit) = record.function_queries[215].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[215].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => { aiur_fn_215::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; if (__v_69 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(222, &__args[..])?) { [G::ZERO; OUT_222] } else { let (__hash, __hit) = record.function_queries[222].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[222].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => { aiur_fn_222::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(223, &__args[..])?) { [G::ZERO; OUT_223] } else { let (__hash, __hit) = record.function_queries[223].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[223].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => { aiur_fn_223::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_71 != __v_72) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None }); } let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_73, __v_73, __v_73]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_74]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_16, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(214, &__args[..])?) { [G::ZERO; OUT_214] } else { let (__hash, __hit) = record.function_queries[214].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[214].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => { aiur_fn_214::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; let __v_77: G = __r_arr[3]; let __v_78: G = __r_arr[4]; let __v_79: G = G::from_u64(0); let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(202, &__args[..])?) { [G::ZERO; OUT_202] } else { let (__hash, __hit) = record.function_queries[202].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[202].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => { aiur_fn_202::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_60, __v_61, __v_22, __v_21, __v_39, __v_40, __v_37, __v_38, __v_36, __v_79, __v_80, __v_81, __v_42, __v_43, __v_44, __v_45, __v_74, __v_75, __v_76, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(200, &__args[..])?) { [G::ZERO; OUT_200] } else { let (__hash, __hit) = record.function_queries[200].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[200].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => { aiur_fn_200::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __v_86: G = __v_85 - __v_84; let __v_87: G = G::from_bool(__v_86 == G::ZERO); let __v_88: G = G::from_u64(1); if (__v_87 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(142, &__args[..])?) { [G::ZERO; OUT_142] } else { let (__hash, __hit) = record.function_queries[142].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[142].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => { aiur_fn_142::(__args, __hash, record, io_buffer)? }, } } }; let __v_91: G = __r_arr[0]; let __v_92: G = __v_90 + __v_91; if (__v_89 != __v_92) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __v_93 - __v_84; let __v_95: G = G::from_bool(__v_94 == G::ZERO); if (__v_95 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_96 != __v_88) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); } let __v_97: G = { let __values: [G; 3] = [__v_88, __v_88, __v_88]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_37.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_97]; }, 1u64 => { let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_38, __v_97]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; break '__mc_1 [__v_98]; }, _ => { return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); }, } }; let __v_98: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_36, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_40, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_39, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(133, &__args[..])?) { [G::ZERO; OUT_133] } else { let (__hash, __hit) = record.function_queries[133].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[133].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => { aiur_fn_133::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_78, __v_101]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_102: G = __r_arr[0]; let __v_103: G = G::from_u64(1); let __v_104: G = { let __values: [G; 3] = [__v_103, __v_103, __v_103]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_102, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(174, &__args[..])?) { [G::ZERO; OUT_174] } else { let (__hash, __hit) = record.function_queries[174].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[174].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => { aiur_fn_174::(__args, __hash, record, io_buffer)? }, } } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; let __v_108: G = __r_arr[3]; let __v_109: G = __r_arr[4]; let __v_110: G = __r_arr[5]; let __v_111: G = __r_arr[6]; let __v_112: G = __r_arr[7]; let __v_113: G = __r_arr[8]; let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = __r_arr[12]; let __v_118: G = __r_arr[13]; let __v_119: G = __r_arr[14]; let __v_120: G = __r_arr[15]; let __v_121: G = __r_arr[16]; let __v_122: G = __r_arr[17]; let __v_123: G = G::from_u64(256); let __v_124: G = __v_123 * __v_106; let __v_125: G = G::from_u64(65536); let __v_126: G = __v_125 * __v_107; let __v_127: G = G::from_u64(16777216); let __v_128: G = __v_127 * __v_108; let __v_129: G = G::from_u64(4294967296); let __v_130: G = __v_129 * __v_109; let __v_131: G = G::from_u64(1099511627776); let __v_132: G = __v_131 * __v_110; let __v_133: G = G::from_u64(281474976710656); let __v_134: G = __v_133 * __v_111; let __v_135: G = G::from_u64(72057594037927936); let __v_136: G = __v_135 * __v_112; let __v_137: G = __v_134 + __v_136; let __v_138: G = __v_132 + __v_137; let __v_139: G = __v_130 + __v_138; let __v_140: G = __v_128 + __v_139; let __v_141: G = __v_126 + __v_140; let __v_142: G = __v_124 + __v_141; let __v_143: G = __v_105 + __v_142; let __v_144: G = __v_123 * __v_114; let __v_145: G = __v_125 * __v_115; let __v_146: G = __v_127 * __v_116; let __v_147: G = __v_129 * __v_117; let __v_148: G = __v_131 * __v_118; let __v_149: G = __v_133 * __v_119; let __v_150: G = __v_135 * __v_120; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_148 + __v_151; let __v_153: G = __v_147 + __v_152; let __v_154: G = __v_146 + __v_153; let __v_155: G = __v_145 + __v_154; let __v_156: G = __v_144 + __v_155; let __v_157: G = __v_113 + __v_156; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_121, __v_23, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(137, &__args[..])?) { [G::ZERO; OUT_137] } else { let (__hash, __hit) = record.function_queries[137].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[137].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => { aiur_fn_137::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(131, &__args[..])?) { [G::ZERO; OUT_131] } else { let (__hash, __hit) = record.function_queries[131].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[131].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => { aiur_fn_131::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_159, __v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_161: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_161, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(135, &__args[..])?) { [G::ZERO; OUT_135] } else { let (__hash, __hit) = record.function_queries[135].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[135].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => { aiur_fn_135::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_162, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(136, &__args[..])?) { [G::ZERO; OUT_136] } else { let (__hash, __hit) = record.function_queries[136].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[136].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => { aiur_fn_136::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = __v_84 + __v_0; let __v_166: G = G::from_u64(33); let __v_167: G = { let __a_val = __v_165.as_canonical_u64(); let __b_val = __v_166.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 65535) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; if (__v_167 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_163, __v_164, __v_4, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(158, &__args[..])?) { [G::ZERO; OUT_158] } else { let (__hash, __hit) = record.function_queries[158].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[158].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => { aiur_fn_158::(__args, __hash, record, io_buffer)? }, } } }; let __v_168: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_25, __v_168, __v_18, __v_19, __v_20, __v_73, __v_37, __v_38, __v_61, __v_22, __v_83, __v_0, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(162, &__args[..])?) { [G::ZERO; OUT_162] } else { let (__hash, __hit) = record.function_queries[162].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[162].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => { aiur_fn_162::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; if (__v_169 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __v_170: G = G::from_u64(0); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(161, &__args[..])?) { [G::ZERO; OUT_161] } else { let (__hash, __hit) = record.function_queries[161].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[161].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => { aiur_fn_161::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_163, __v_164, __v_171, __v_143, __v_157, __v_39, __v_40, __v_36, __v_37, __v_38, __v_18, __v_19, __v_20, __v_73, __v_61, __v_22, __v_76, __v_77, __v_83, __v_0, __v_165, __v_158, __v_23, __v_27, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(157, &__args[..])?) { [G::ZERO; OUT_157] } else { let (__hash, __hit) = record.function_queries[157].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[157].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => { aiur_fn_157::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(165, &__args[..])?) { [G::ZERO; OUT_165] } else { let (__hash, __hit) = record.function_queries[165].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[165].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => { aiur_fn_165::(__args, __hash, record, io_buffer)? }, } } }; let __v_173: G = __r_arr[0]; if (__v_173 != __v_103) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(219, &__args[..])?) { [G::ZERO; OUT_219] } else { let (__hash, __hit) = record.function_queries[219].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[219].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => { aiur_fn_219::(__args, __hash, record, io_buffer)? }, } } }; let __v_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_229] = [__v_174, __v_175]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } const INPUT_SIZE_230: usize = 22; const IN_230: usize = 22; const OUT_230: usize = 2; -fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; let __v_26: G = __loaded[4]; let __v_27: G = __loaded[5]; match __v_22.as_canonical_u64() { 1u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; let __v_54: G = G::from_u64(1); if (__v_28 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_29 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_30 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_31 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_32 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_33 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_34 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_35 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_36 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_37 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_38 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_39 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_40 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_41 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_42 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_43 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_44 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_45 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_46 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_47 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_48 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_49 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_50 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_51 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_52 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_53 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_230] = [__v_20, __v_21]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, (&__args[..]))?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { (*(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229])) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_14 + __v_56); let __v_58: G = (__v_20 + __v_54); let __v_59: G = (__v_21 + __v_55); let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_27, __v_53, __v_57, __v_15, __v_16, __v_17, __v_18, __v_19, __v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_230] = [__v_60, __v_61]; record.function_queries[230].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }) } +fn aiur_fn_230(inp: [G; IN_230], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; let __v_26: G = __loaded[4]; let __v_27: G = __loaded[5]; match __v_22.as_canonical_u64() { 1u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; let __v_54: G = G::from_u64(1); if (__v_28 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_29 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_30 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_31 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_32 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_33 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_34 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_35 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_36 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_37 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_38 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_39 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_40 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_41 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_42 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_43 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_44 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_45 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_46 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_47 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_48 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_49 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_50 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_51 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_52 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } if (__v_53 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_230] = [__v_20, __v_21]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; let __v_31: G = __loaded[3]; let __v_32: G = __loaded[4]; let __v_33: G = __loaded[5]; let __v_34: G = __loaded[6]; let __v_35: G = __loaded[7]; let __v_36: G = __loaded[8]; let __v_37: G = __loaded[9]; let __v_38: G = __loaded[10]; let __v_39: G = __loaded[11]; let __v_40: G = __loaded[12]; let __v_41: G = __loaded[13]; let __v_42: G = __loaded[14]; let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; let __v_46: G = __loaded[18]; let __v_47: G = __loaded[19]; let __v_48: G = __loaded[20]; let __v_49: G = __loaded[21]; let __v_50: G = __loaded[22]; let __v_51: G = __loaded[23]; let __v_52: G = __loaded[24]; let __v_53: G = __loaded[25]; match __v_28.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(229, &__args[..])?) { [G::ZERO; OUT_229] } else { let (__hash, __hit) = record.function_queries[229].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[229].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => { aiur_fn_229::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(1); let __v_57: G = __v_14 + __v_56; let __v_58: G = __v_20 + __v_54; let __v_59: G = __v_21 + __v_55; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_27, __v_53, __v_57, __v_15, __v_16, __v_17, __v_18, __v_19, __v_58, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_230] = [__v_60, __v_61]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }) } const INPUT_SIZE_231: usize = 1; const IN_231: usize = 1; const OUT_231: usize = 1; -fn aiur_fn_231(inp: [G; IN_231], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, (&__args[..]))?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { (*(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231])) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_231(inp: [G; IN_231], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, &__args[..])?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_8]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_232: usize = 15; const IN_232: usize = 15; const OUT_232: usize = 1; -fn aiur_fn_232(inp: [G; IN_232], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(224, (&__args[..]))?) { [G::ZERO; OUT_224] } else { let (__hash, __hit) = record.function_queries[224].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[224].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { (*(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224])) }; __ret }, _ => { aiur_fn_224::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, (&__args[..]))?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { (*(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228])) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; break '__mc_0 [__v_23]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_22: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_22, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, (&__args[..]))?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { (*(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213])) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, (&__args[..]))?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { (*(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220])) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_28, __v_27, __v_23, __v_24, __v_25, __v_26, __v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, (&__args[..]))?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { (*(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230])) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_bool((__v_31 == G::ZERO)); let __v_34: G = G::from_bool((__v_32 == G::ZERO)); let __v_35: G = (__v_33 * __v_34); let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, (&__args[..]))?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { (*(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231])) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_232] = [__v_37]; record.function_queries[232].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }, } }) } +fn aiur_fn_232(inp: [G; IN_232], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(224, &__args[..])?) { [G::ZERO; OUT_224] } else { let (__hash, __hit) = record.function_queries[224].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[224].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => { aiur_fn_224::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(228, &__args[..])?) { [G::ZERO; OUT_228] } else { let (__hash, __hit) = record.function_queries[228].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[228].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => { aiur_fn_228::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; break '__mc_0 [__v_23]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_22: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_22, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(213, &__args[..])?) { [G::ZERO; OUT_213] } else { let (__hash, __hit) = record.function_queries[213].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[213].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => { aiur_fn_213::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(220, &__args[..])?) { [G::ZERO; OUT_220] } else { let (__hash, __hit) = record.function_queries[220].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[220].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => { aiur_fn_220::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_28, __v_27, __v_23, __v_24, __v_25, __v_26, __v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(230, &__args[..])?) { [G::ZERO; OUT_230] } else { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[230].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => { aiur_fn_230::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_bool(__v_31 == G::ZERO); let __v_34: G = G::from_bool(__v_32 == G::ZERO); let __v_35: G = __v_33 * __v_34; let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(231, &__args[..])?) { [G::ZERO; OUT_231] } else { let (__hash, __hit) = record.function_queries[231].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[231].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => { aiur_fn_231::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_232] = [__v_37]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } const INPUT_SIZE_233: usize = 15; const IN_233: usize = 15; const OUT_233: usize = 1; -fn aiur_fn_233(inp: [G; IN_233], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = (__v_12 + __v_13); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17, __v_21, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, (&__args[..]))?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { (*(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232])) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_28, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_233] = [__v_30]; record.function_queries[233].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_233(inp: [G; IN_233], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __v_12 + __v_13; if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_17, __v_21, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, &__args[..])?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_28, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_233] = [__v_30]; record.function_queries[233].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_234: usize = 1; const IN_234: usize = 1; const OUT_234: usize = 2; -fn aiur_fn_234(inp: [G; IN_234], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_234] = [__v_3, __v_4]; record.function_queries[234].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_234(inp: [G; IN_234], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_234] = [__v_3, __v_4]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_235: usize = 2; const IN_235: usize = 2; const OUT_235: usize = 2; -fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_3, __v_0]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, (&__args[..]))?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { (*(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237])) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_11, __v_9]; record.function_queries[235].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_235(inp: [G; IN_235], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_3, __v_0]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, &__args[..])?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_235] = [__v_11, __v_9]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_236: usize = 1; const IN_236: usize = 1; const OUT_236: usize = 2; -fn aiur_fn_236(inp: [G; IN_236], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, (&__args[..]))?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { (*(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237])) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_3, __v_4]; record.function_queries[236].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_236(inp: [G; IN_236], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, &__args[..])?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_3, __v_4]; record.function_queries[236].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_237: usize = 2; const IN_237: usize = 2; const OUT_237: usize = 2; -fn aiur_fn_237(inp: [G; IN_237], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_3, __v_0]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, (&__args[..]))?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { (*(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25])) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, (&__args[..]))?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { (*(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237])) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_16, __v_14]; record.function_queries[237].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, } }) } +fn aiur_fn_237(inp: [G; IN_237], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 10] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_3, __v_0]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(25, &__args[..])?) { [G::ZERO; OUT_25] } else { let (__hash, __hit) = record.function_queries[25].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[25].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => { aiur_fn_25::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(237, &__args[..])?) { [G::ZERO; OUT_237] } else { let (__hash, __hit) = record.function_queries[237].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[237].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => { aiur_fn_237::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_237] = [__v_16, __v_14]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } const INPUT_SIZE_238: usize = 16; const IN_238: usize = 16; const OUT_238: usize = 0; -fn aiur_fn_238(inp: [G; IN_238], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_16, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_17: G = __io_pair.0; let __v_18: G = __io_pair.1; let __v_19: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_19, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_20: G = __io_pair.0; let __v_21: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_19, __v_20, __v_21]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(103); let __v_24: G = G::from_u64(230); let __v_25: G = G::from_u64(9); let __v_26: G = G::from_u64(106); let __v_27: G = G::from_u64(133); let __v_28: G = G::from_u64(174); let __v_29: G = G::from_u64(187); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(243); let __v_32: G = G::from_u64(110); let __v_33: G = G::from_u64(60); let __v_34: G = G::from_u64(58); let __v_35: G = G::from_u64(245); let __v_36: G = G::from_u64(79); let __v_37: G = G::from_u64(165); let __v_38: G = G::from_u64(127); let __v_39: G = G::from_u64(82); let __v_40: G = G::from_u64(14); let __v_41: G = G::from_u64(81); let __v_42: G = G::from_u64(140); let __v_43: G = G::from_u64(104); let __v_44: G = G::from_u64(5); let __v_45: G = G::from_u64(155); let __v_46: G = G::from_u64(171); let __v_47: G = G::from_u64(217); let __v_48: G = G::from_u64(131); let __v_49: G = G::from_u64(31); let __v_50: G = G::from_u64(25); let __v_51: G = G::from_u64(205); let __v_52: G = G::from_u64(224); let __v_53: G = G::from_u64(91); let __v_54: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 8] = [__v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 8)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 32] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_23, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 32)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 34] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 34)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_22, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = __r_arr[3]; let __v_63: G = __r_arr[4]; let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __v_67: G = __r_arr[8]; let __v_68: G = __r_arr[9]; let __v_69: G = __r_arr[10]; let __v_70: G = __r_arr[11]; let __v_71: G = __r_arr[12]; let __v_72: G = __r_arr[13]; let __v_73: G = __r_arr[14]; let __v_74: G = __r_arr[15]; let __v_75: G = __r_arr[16]; let __v_76: G = __r_arr[17]; let __v_77: G = __r_arr[18]; let __v_78: G = __r_arr[19]; let __v_79: G = __r_arr[20]; let __v_80: G = __r_arr[21]; let __v_81: G = __r_arr[22]; let __v_82: G = __r_arr[23]; let __v_83: G = __r_arr[24]; let __v_84: G = __r_arr[25]; let __v_85: G = __r_arr[26]; let __v_86: G = __r_arr[27]; let __v_87: G = __r_arr[28]; let __v_88: G = __r_arr[29]; let __v_89: G = __r_arr[30]; let __v_90: G = __r_arr[31]; let __v_91: G = G::from_u64(256); let __v_92: G = (__v_91 * __v_60); let __v_93: G = G::from_u64(65536); let __v_94: G = (__v_93 * __v_61); let __v_95: G = G::from_u64(16777216); let __v_96: G = (__v_95 * __v_62); let __v_97: G = (__v_94 + __v_96); let __v_98: G = (__v_92 + __v_97); let __v_99: G = (__v_59 + __v_98); let __v_100: G = (__v_91 * __v_64); let __v_101: G = (__v_93 * __v_65); let __v_102: G = (__v_95 * __v_66); let __v_103: G = (__v_101 + __v_102); let __v_104: G = (__v_100 + __v_103); let __v_105: G = (__v_63 + __v_104); let __v_106: G = (__v_91 * __v_68); let __v_107: G = (__v_93 * __v_69); let __v_108: G = (__v_95 * __v_70); let __v_109: G = (__v_107 + __v_108); let __v_110: G = (__v_106 + __v_109); let __v_111: G = (__v_67 + __v_110); let __v_112: G = (__v_91 * __v_72); let __v_113: G = (__v_93 * __v_73); let __v_114: G = (__v_95 * __v_74); let __v_115: G = (__v_113 + __v_114); let __v_116: G = (__v_112 + __v_115); let __v_117: G = (__v_71 + __v_116); let __v_118: G = (__v_91 * __v_76); let __v_119: G = (__v_93 * __v_77); let __v_120: G = (__v_95 * __v_78); let __v_121: G = (__v_119 + __v_120); let __v_122: G = (__v_118 + __v_121); let __v_123: G = (__v_75 + __v_122); let __v_124: G = (__v_91 * __v_80); let __v_125: G = (__v_93 * __v_81); let __v_126: G = (__v_95 * __v_82); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_124 + __v_127); let __v_129: G = (__v_79 + __v_128); let __v_130: G = (__v_91 * __v_84); let __v_131: G = (__v_93 * __v_85); let __v_132: G = (__v_95 * __v_86); let __v_133: G = (__v_131 + __v_132); let __v_134: G = (__v_130 + __v_133); let __v_135: G = (__v_83 + __v_134); let __v_136: G = (__v_91 * __v_88); let __v_137: G = (__v_93 * __v_89); let __v_138: G = (__v_95 * __v_90); let __v_139: G = (__v_137 + __v_138); let __v_140: G = (__v_136 + __v_139); let __v_141: G = (__v_87 + __v_140); if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_151]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; let __v_155: G = __r_arr[3]; let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = __r_arr[6]; let __v_159: G = __r_arr[7]; let __v_160: G = __r_arr[8]; let __v_161: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __v_164: G = __r_arr[2]; let __v_165: G = __r_arr[3]; let __v_166: G = __r_arr[4]; let __v_167: G = __r_arr[5]; let __v_168: G = __r_arr[6]; let __v_169: G = __r_arr[7]; let __v_170: G = __r_arr[8]; let __v_171: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_171]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; let __v_175: G = __r_arr[3]; let __v_176: G = __r_arr[4]; let __v_177: G = __r_arr[5]; let __v_178: G = __r_arr[6]; let __v_179: G = __r_arr[7]; let __v_180: G = __r_arr[8]; let __v_181: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __v_184: G = __r_arr[2]; let __v_185: G = __r_arr[3]; let __v_186: G = __r_arr[4]; let __v_187: G = __r_arr[5]; let __v_188: G = __r_arr[6]; let __v_189: G = __r_arr[7]; let __v_190: G = __r_arr[8]; let __v_191: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_191]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_192: G = __r_arr[0]; let __v_193: G = __r_arr[1]; let __v_194: G = __r_arr[2]; let __v_195: G = __r_arr[3]; let __v_196: G = __r_arr[4]; let __v_197: G = __r_arr[5]; let __v_198: G = __r_arr[6]; let __v_199: G = __r_arr[7]; let __v_200: G = __r_arr[8]; let __v_201: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_201]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __v_203: G = __r_arr[1]; let __v_204: G = __r_arr[2]; let __v_205: G = __r_arr[3]; let __v_206: G = __r_arr[4]; let __v_207: G = __r_arr[5]; let __v_208: G = __r_arr[6]; let __v_209: G = __r_arr[7]; let __v_210: G = __r_arr[8]; let __v_211: G = __r_arr[9]; let __v_212: G = { let __values: [G; 10] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_213: G = { let __values: [G; 10] = [__v_16, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_212]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_214: G = { let __values: [G; 10] = [__v_16, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_213]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_215: G = { let __values: [G; 10] = [__v_16, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_214]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_216: G = { let __values: [G; 10] = [__v_16, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_215]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_217: G = { let __values: [G; 10] = [__v_16, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_216]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_218: G = { let __values: [G; 10] = [__v_16, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_217]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __v_219: G = { let __values: [G; 10] = [__v_16, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_218]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_211]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, (&__args[..]))?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { (*(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87])) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; let __v_223: G = __r_arr[3]; let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = __r_arr[6]; let __v_227: G = __r_arr[7]; let __v_228: G = __r_arr[8]; let __v_229: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_229, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, (&__args[..]))?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { (*(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100])) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_230: G = __r_arr[0]; let __v_231: G = __r_arr[1]; let __v_232: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_232]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, (&__args[..]))?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { (*(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101])) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_233: G = __r_arr[0]; let __v_234: G = __r_arr[1]; let __v_235: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_235, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, (&__args[..]))?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { (*(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102])) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_236: G = __r_arr[0]; let __v_237: G = __r_arr[1]; let __v_238: G = { let __values: [G; 10] = [__v_16, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_231]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_219, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_239: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_237.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_240: G = __loaded[0]; let __v_241: G = __loaded[1]; let __v_242: G = __loaded[2]; if (__v_240 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_241 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_242 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_243: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_243, (&__key[..]))?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_244: G = __io_pair.0; let __v_245: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_243, __v_244, __v_245]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup((&__args[..])); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { (*(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1])) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_246: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_246, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, (&__args[..]))?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { (*(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75])) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_247: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_247]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, (&__args[..]))?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { (*(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74])) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_248: G = __r_arr[0]; let __v_249: G = __r_arr[1]; let __v_250: G = __r_arr[2]; let __v_251: G = __r_arr[3]; let __v_252: G = __r_arr[4]; let __v_253: G = __r_arr[5]; let __v_254: G = __r_arr[6]; let __v_255: G = __r_arr[7]; let __v_256: G = __r_arr[8]; let __v_257: G = __r_arr[9]; let __v_258: G = __r_arr[10]; let __v_259: G = __r_arr[11]; let __v_260: G = __r_arr[12]; let __v_261: G = __r_arr[13]; let __v_262: G = __r_arr[14]; let __v_263: G = __r_arr[15]; let __v_264: G = __r_arr[16]; let __v_265: G = __r_arr[17]; let __v_266: G = __r_arr[18]; let __v_267: G = __r_arr[19]; let __v_268: G = __r_arr[20]; let __v_269: G = __r_arr[21]; let __v_270: G = __r_arr[22]; let __v_271: G = __r_arr[23]; let __v_272: G = __r_arr[24]; let __v_273: G = __r_arr[25]; let __v_274: G = __r_arr[26]; let __v_275: G = __r_arr[27]; let __v_276: G = __r_arr[28]; let __v_277: G = __r_arr[29]; let __v_278: G = __r_arr[30]; let __v_279: G = __r_arr[31]; let __v_280: G = (__v_91 * __v_249); let __v_281: G = (__v_93 * __v_250); let __v_282: G = (__v_95 * __v_251); let __v_283: G = (__v_281 + __v_282); let __v_284: G = (__v_280 + __v_283); let __v_285: G = (__v_248 + __v_284); let __v_286: G = (__v_91 * __v_253); let __v_287: G = (__v_93 * __v_254); let __v_288: G = (__v_95 * __v_255); let __v_289: G = (__v_287 + __v_288); let __v_290: G = (__v_286 + __v_289); let __v_291: G = (__v_252 + __v_290); let __v_292: G = (__v_91 * __v_257); let __v_293: G = (__v_93 * __v_258); let __v_294: G = (__v_95 * __v_259); let __v_295: G = (__v_293 + __v_294); let __v_296: G = (__v_292 + __v_295); let __v_297: G = (__v_256 + __v_296); let __v_298: G = (__v_91 * __v_261); let __v_299: G = (__v_93 * __v_262); let __v_300: G = (__v_95 * __v_263); let __v_301: G = (__v_299 + __v_300); let __v_302: G = (__v_298 + __v_301); let __v_303: G = (__v_260 + __v_302); let __v_304: G = (__v_91 * __v_265); let __v_305: G = (__v_93 * __v_266); let __v_306: G = (__v_95 * __v_267); let __v_307: G = (__v_305 + __v_306); let __v_308: G = (__v_304 + __v_307); let __v_309: G = (__v_264 + __v_308); let __v_310: G = (__v_91 * __v_269); let __v_311: G = (__v_93 * __v_270); let __v_312: G = (__v_95 * __v_271); let __v_313: G = (__v_311 + __v_312); let __v_314: G = (__v_310 + __v_313); let __v_315: G = (__v_268 + __v_314); let __v_316: G = (__v_91 * __v_273); let __v_317: G = (__v_93 * __v_274); let __v_318: G = (__v_95 * __v_275); let __v_319: G = (__v_317 + __v_318); let __v_320: G = (__v_316 + __v_319); let __v_321: G = (__v_272 + __v_320); let __v_322: G = (__v_91 * __v_277); let __v_323: G = (__v_93 * __v_278); let __v_324: G = (__v_95 * __v_279); let __v_325: G = (__v_323 + __v_324); let __v_326: G = (__v_322 + __v_325); let __v_327: G = (__v_276 + __v_326); if (__v_285 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_291 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_291.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_297 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_297.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_303 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_309 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_315 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_315.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_321 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_321.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_327 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_327.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_246]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, (&__args[..]))?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { (*(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26])) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_328: G = __r_arr[0]; let __v_329: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_329, __v_328]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, (&__args[..]))?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { (*(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235])) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_330: G = __r_arr[0]; let __v_331: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_331.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_332: G = __loaded[0]; let __v_333: G = __loaded[1]; let __v_334: G = __loaded[2]; if (__v_332 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_332.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_333 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_333.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_334 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_334.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_335: G = __r_arr[0]; let __v_336: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_336, __v_335]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, (&__args[..]))?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { (*(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63])) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_337: G = __r_arr[0]; let __v_338: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_338]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_339: G = __r_arr[0]; let __v_340: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_340, __v_339]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, (&__args[..]))?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { (*(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66])) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_341: G = __r_arr[0]; let __v_342: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_342]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, (&__args[..]))?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { (*(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29])) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_343: G = __r_arr[0]; let __v_344: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_344, __v_343]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, (&__args[..]))?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { (*(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68])) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_345: G = __r_arr[0]; let __v_346: G = __r_arr[1]; let __v_347: G = (__v_17 + __v_18); if (__v_346 != __v_347) { return Err(ExecError::AssertEqMismatch { lhs: __v_346.as_canonical_u64(), rhs: __v_347.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_142, __v_152, __v_162, __v_172, __v_182, __v_192, __v_202, __v_239, __v_230, __v_233, __v_234, __v_236, __v_337, __v_341, __v_345]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, (&__args[..]))?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { (*(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232])) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_348: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_348, __v_330]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, (&__args[..]))?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { (*(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217])) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_349: G = __r_arr[0]; if (__v_349 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_349.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_19 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_238] = []; record.function_queries[238].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }) } +fn aiur_fn_238(inp: [G; IN_238], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_17: G = __io_pair.0; let __v_18: G = __io_pair.1; let __v_19: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_19, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_20: G = __io_pair.0; let __v_21: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_19, __v_20, __v_21]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(103); let __v_24: G = G::from_u64(230); let __v_25: G = G::from_u64(9); let __v_26: G = G::from_u64(106); let __v_27: G = G::from_u64(133); let __v_28: G = G::from_u64(174); let __v_29: G = G::from_u64(187); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(243); let __v_32: G = G::from_u64(110); let __v_33: G = G::from_u64(60); let __v_34: G = G::from_u64(58); let __v_35: G = G::from_u64(245); let __v_36: G = G::from_u64(79); let __v_37: G = G::from_u64(165); let __v_38: G = G::from_u64(127); let __v_39: G = G::from_u64(82); let __v_40: G = G::from_u64(14); let __v_41: G = G::from_u64(81); let __v_42: G = G::from_u64(140); let __v_43: G = G::from_u64(104); let __v_44: G = G::from_u64(5); let __v_45: G = G::from_u64(155); let __v_46: G = G::from_u64(171); let __v_47: G = G::from_u64(217); let __v_48: G = G::from_u64(131); let __v_49: G = G::from_u64(31); let __v_50: G = G::from_u64(25); let __v_51: G = G::from_u64(205); let __v_52: G = G::from_u64(224); let __v_53: G = G::from_u64(91); let __v_54: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_55: G = { let __values: [G; 8] = [__v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(5).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(8))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 8)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_56: G = { let __values: [G; 32] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_23, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 32)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_57: G = { let __values: [G; 34] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(34))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 34)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_22, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; let __v_62: G = __r_arr[3]; let __v_63: G = __r_arr[4]; let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __v_67: G = __r_arr[8]; let __v_68: G = __r_arr[9]; let __v_69: G = __r_arr[10]; let __v_70: G = __r_arr[11]; let __v_71: G = __r_arr[12]; let __v_72: G = __r_arr[13]; let __v_73: G = __r_arr[14]; let __v_74: G = __r_arr[15]; let __v_75: G = __r_arr[16]; let __v_76: G = __r_arr[17]; let __v_77: G = __r_arr[18]; let __v_78: G = __r_arr[19]; let __v_79: G = __r_arr[20]; let __v_80: G = __r_arr[21]; let __v_81: G = __r_arr[22]; let __v_82: G = __r_arr[23]; let __v_83: G = __r_arr[24]; let __v_84: G = __r_arr[25]; let __v_85: G = __r_arr[26]; let __v_86: G = __r_arr[27]; let __v_87: G = __r_arr[28]; let __v_88: G = __r_arr[29]; let __v_89: G = __r_arr[30]; let __v_90: G = __r_arr[31]; let __v_91: G = G::from_u64(256); let __v_92: G = __v_91 * __v_60; let __v_93: G = G::from_u64(65536); let __v_94: G = __v_93 * __v_61; let __v_95: G = G::from_u64(16777216); let __v_96: G = __v_95 * __v_62; let __v_97: G = __v_94 + __v_96; let __v_98: G = __v_92 + __v_97; let __v_99: G = __v_59 + __v_98; let __v_100: G = __v_91 * __v_64; let __v_101: G = __v_93 * __v_65; let __v_102: G = __v_95 * __v_66; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_100 + __v_103; let __v_105: G = __v_63 + __v_104; let __v_106: G = __v_91 * __v_68; let __v_107: G = __v_93 * __v_69; let __v_108: G = __v_95 * __v_70; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_106 + __v_109; let __v_111: G = __v_67 + __v_110; let __v_112: G = __v_91 * __v_72; let __v_113: G = __v_93 * __v_73; let __v_114: G = __v_95 * __v_74; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_112 + __v_115; let __v_117: G = __v_71 + __v_116; let __v_118: G = __v_91 * __v_76; let __v_119: G = __v_93 * __v_77; let __v_120: G = __v_95 * __v_78; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_118 + __v_121; let __v_123: G = __v_75 + __v_122; let __v_124: G = __v_91 * __v_80; let __v_125: G = __v_93 * __v_81; let __v_126: G = __v_95 * __v_82; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_124 + __v_127; let __v_129: G = __v_79 + __v_128; let __v_130: G = __v_91 * __v_84; let __v_131: G = __v_93 * __v_85; let __v_132: G = __v_95 * __v_86; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_130 + __v_133; let __v_135: G = __v_83 + __v_134; let __v_136: G = __v_91 * __v_88; let __v_137: G = __v_93 * __v_89; let __v_138: G = __v_95 * __v_90; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_136 + __v_139; let __v_141: G = __v_87 + __v_140; if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __v_144: G = __r_arr[2]; let __v_145: G = __r_arr[3]; let __v_146: G = __r_arr[4]; let __v_147: G = __r_arr[5]; let __v_148: G = __r_arr[6]; let __v_149: G = __r_arr[7]; let __v_150: G = __r_arr[8]; let __v_151: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_151]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; let __v_155: G = __r_arr[3]; let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = __r_arr[6]; let __v_159: G = __r_arr[7]; let __v_160: G = __r_arr[8]; let __v_161: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __v_164: G = __r_arr[2]; let __v_165: G = __r_arr[3]; let __v_166: G = __r_arr[4]; let __v_167: G = __r_arr[5]; let __v_168: G = __r_arr[6]; let __v_169: G = __r_arr[7]; let __v_170: G = __r_arr[8]; let __v_171: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_171]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; let __v_175: G = __r_arr[3]; let __v_176: G = __r_arr[4]; let __v_177: G = __r_arr[5]; let __v_178: G = __r_arr[6]; let __v_179: G = __r_arr[7]; let __v_180: G = __r_arr[8]; let __v_181: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __v_184: G = __r_arr[2]; let __v_185: G = __r_arr[3]; let __v_186: G = __r_arr[4]; let __v_187: G = __r_arr[5]; let __v_188: G = __r_arr[6]; let __v_189: G = __r_arr[7]; let __v_190: G = __r_arr[8]; let __v_191: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_191]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_192: G = __r_arr[0]; let __v_193: G = __r_arr[1]; let __v_194: G = __r_arr[2]; let __v_195: G = __r_arr[3]; let __v_196: G = __r_arr[4]; let __v_197: G = __r_arr[5]; let __v_198: G = __r_arr[6]; let __v_199: G = __r_arr[7]; let __v_200: G = __r_arr[8]; let __v_201: G = __r_arr[9]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_201]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __v_203: G = __r_arr[1]; let __v_204: G = __r_arr[2]; let __v_205: G = __r_arr[3]; let __v_206: G = __r_arr[4]; let __v_207: G = __r_arr[5]; let __v_208: G = __r_arr[6]; let __v_209: G = __r_arr[7]; let __v_210: G = __r_arr[8]; let __v_211: G = __r_arr[9]; let __v_212: G = { let __values: [G; 10] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_213: G = { let __values: [G; 10] = [__v_16, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_212]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_214: G = { let __values: [G; 10] = [__v_16, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_213]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_215: G = { let __values: [G; 10] = [__v_16, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_214]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_216: G = { let __values: [G; 10] = [__v_16, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_215]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_217: G = { let __values: [G; 10] = [__v_16, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_216]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_218: G = { let __values: [G; 10] = [__v_16, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_217]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __v_219: G = { let __values: [G; 10] = [__v_16, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_218]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_211]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(87, &__args[..])?) { [G::ZERO; OUT_87] } else { let (__hash, __hit) = record.function_queries[87].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[87].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => { aiur_fn_87::(__args, __hash, record, io_buffer)? }, } } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; let __v_223: G = __r_arr[3]; let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = __r_arr[6]; let __v_227: G = __r_arr[7]; let __v_228: G = __r_arr[8]; let __v_229: G = __r_arr[9]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_229, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(100, &__args[..])?) { [G::ZERO; OUT_100] } else { let (__hash, __hit) = record.function_queries[100].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[100].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => { aiur_fn_100::(__args, __hash, record, io_buffer)? }, } } }; let __v_230: G = __r_arr[0]; let __v_231: G = __r_arr[1]; let __v_232: G = __r_arr[2]; let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_232]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(101, &__args[..])?) { [G::ZERO; OUT_101] } else { let (__hash, __hit) = record.function_queries[101].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[101].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => { aiur_fn_101::(__args, __hash, record, io_buffer)? }, } } }; let __v_233: G = __r_arr[0]; let __v_234: G = __r_arr[1]; let __v_235: G = __r_arr[2]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_235, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(102, &__args[..])?) { [G::ZERO; OUT_102] } else { let (__hash, __hit) = record.function_queries[102].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[102].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => { aiur_fn_102::(__args, __hash, record, io_buffer)? }, } } }; let __v_236: G = __r_arr[0]; let __v_237: G = __r_arr[1]; let __v_238: G = { let __values: [G; 10] = [__v_16, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_231]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_219, __v_238]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, &__args[..])?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_239: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_237.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_240: G = __loaded[0]; let __v_241: G = __loaded[1]; let __v_242: G = __loaded[2]; if (__v_240 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_241 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_242 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_243: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_16]; let __info = io_buffer.get_info(__v_243, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_244: G = __io_pair.0; let __v_245: G = __io_pair.1; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_243, __v_244, __v_245]; let __cu = true; { let (__hash, __hit) = record.function_queries[1].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => { aiur_fn_1::(__args, __hash, record, io_buffer)? }, } } }; let __v_246: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_246, __v_54, __v_16, __v_16, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(75, &__args[..])?) { [G::ZERO; OUT_75] } else { let (__hash, __hit) = record.function_queries[75].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[75].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => { aiur_fn_75::(__args, __hash, record, io_buffer)? }, } } }; let __v_247: G = __r_arr[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_247]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(74, &__args[..])?) { [G::ZERO; OUT_74] } else { let (__hash, __hit) = record.function_queries[74].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[74].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => { aiur_fn_74::(__args, __hash, record, io_buffer)? }, } } }; let __v_248: G = __r_arr[0]; let __v_249: G = __r_arr[1]; let __v_250: G = __r_arr[2]; let __v_251: G = __r_arr[3]; let __v_252: G = __r_arr[4]; let __v_253: G = __r_arr[5]; let __v_254: G = __r_arr[6]; let __v_255: G = __r_arr[7]; let __v_256: G = __r_arr[8]; let __v_257: G = __r_arr[9]; let __v_258: G = __r_arr[10]; let __v_259: G = __r_arr[11]; let __v_260: G = __r_arr[12]; let __v_261: G = __r_arr[13]; let __v_262: G = __r_arr[14]; let __v_263: G = __r_arr[15]; let __v_264: G = __r_arr[16]; let __v_265: G = __r_arr[17]; let __v_266: G = __r_arr[18]; let __v_267: G = __r_arr[19]; let __v_268: G = __r_arr[20]; let __v_269: G = __r_arr[21]; let __v_270: G = __r_arr[22]; let __v_271: G = __r_arr[23]; let __v_272: G = __r_arr[24]; let __v_273: G = __r_arr[25]; let __v_274: G = __r_arr[26]; let __v_275: G = __r_arr[27]; let __v_276: G = __r_arr[28]; let __v_277: G = __r_arr[29]; let __v_278: G = __r_arr[30]; let __v_279: G = __r_arr[31]; let __v_280: G = __v_91 * __v_249; let __v_281: G = __v_93 * __v_250; let __v_282: G = __v_95 * __v_251; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_280 + __v_283; let __v_285: G = __v_248 + __v_284; let __v_286: G = __v_91 * __v_253; let __v_287: G = __v_93 * __v_254; let __v_288: G = __v_95 * __v_255; let __v_289: G = __v_287 + __v_288; let __v_290: G = __v_286 + __v_289; let __v_291: G = __v_252 + __v_290; let __v_292: G = __v_91 * __v_257; let __v_293: G = __v_93 * __v_258; let __v_294: G = __v_95 * __v_259; let __v_295: G = __v_293 + __v_294; let __v_296: G = __v_292 + __v_295; let __v_297: G = __v_256 + __v_296; let __v_298: G = __v_91 * __v_261; let __v_299: G = __v_93 * __v_262; let __v_300: G = __v_95 * __v_263; let __v_301: G = __v_299 + __v_300; let __v_302: G = __v_298 + __v_301; let __v_303: G = __v_260 + __v_302; let __v_304: G = __v_91 * __v_265; let __v_305: G = __v_93 * __v_266; let __v_306: G = __v_95 * __v_267; let __v_307: G = __v_305 + __v_306; let __v_308: G = __v_304 + __v_307; let __v_309: G = __v_264 + __v_308; let __v_310: G = __v_91 * __v_269; let __v_311: G = __v_93 * __v_270; let __v_312: G = __v_95 * __v_271; let __v_313: G = __v_311 + __v_312; let __v_314: G = __v_310 + __v_313; let __v_315: G = __v_268 + __v_314; let __v_316: G = __v_91 * __v_273; let __v_317: G = __v_93 * __v_274; let __v_318: G = __v_95 * __v_275; let __v_319: G = __v_317 + __v_318; let __v_320: G = __v_316 + __v_319; let __v_321: G = __v_272 + __v_320; let __v_322: G = __v_91 * __v_277; let __v_323: G = __v_93 * __v_278; let __v_324: G = __v_95 * __v_279; let __v_325: G = __v_323 + __v_324; let __v_326: G = __v_322 + __v_325; let __v_327: G = __v_276 + __v_326; if (__v_285 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_291 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_291.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_297 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_297.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_303 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_309 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_315 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_315.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_321 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_321.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_327 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_327.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_246]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(26, &__args[..])?) { [G::ZERO; OUT_26] } else { let (__hash, __hit) = record.function_queries[26].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[26].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => { aiur_fn_26::(__args, __hash, record, io_buffer)? }, } } }; let __v_328: G = __r_arr[0]; let __v_329: G = __r_arr[1]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_329, __v_328]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(235, &__args[..])?) { [G::ZERO; OUT_235] } else { let (__hash, __hit) = record.function_queries[235].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[235].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => { aiur_fn_235::(__args, __hash, record, io_buffer)? }, } } }; let __v_330: G = __r_arr[0]; let __v_331: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_331.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_332: G = __loaded[0]; let __v_333: G = __loaded[1]; let __v_334: G = __loaded[2]; if (__v_332 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_332.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_333 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_333.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_334 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_334.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_335: G = __r_arr[0]; let __v_336: G = __r_arr[1]; let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_336, __v_335]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(63, &__args[..])?) { [G::ZERO; OUT_63] } else { let (__hash, __hit) = record.function_queries[63].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[63].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => { aiur_fn_63::(__args, __hash, record, io_buffer)? }, } } }; let __v_337: G = __r_arr[0]; let __v_338: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_338]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_339: G = __r_arr[0]; let __v_340: G = __r_arr[1]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_340, __v_339]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(66, &__args[..])?) { [G::ZERO; OUT_66] } else { let (__hash, __hit) = record.function_queries[66].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[66].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => { aiur_fn_66::(__args, __hash, record, io_buffer)? }, } } }; let __v_341: G = __r_arr[0]; let __v_342: G = __r_arr[1]; let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_342]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(29, &__args[..])?) { [G::ZERO; OUT_29] } else { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[29].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => { aiur_fn_29::(__args, __hash, record, io_buffer)? }, } } }; let __v_343: G = __r_arr[0]; let __v_344: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_344, __v_343]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(68, &__args[..])?) { [G::ZERO; OUT_68] } else { let (__hash, __hit) = record.function_queries[68].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[68].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => { aiur_fn_68::(__args, __hash, record, io_buffer)? }, } } }; let __v_345: G = __r_arr[0]; let __v_346: G = __r_arr[1]; let __v_347: G = __v_17 + __v_18; if (__v_346 != __v_347) { return Err(ExecError::AssertEqMismatch { lhs: __v_346.as_canonical_u64(), rhs: __v_347.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_142, __v_152, __v_162, __v_172, __v_182, __v_192, __v_202, __v_239, __v_230, __v_233, __v_234, __v_236, __v_337, __v_341, __v_345]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(232, &__args[..])?) { [G::ZERO; OUT_232] } else { let (__hash, __hit) = record.function_queries[232].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[232].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => { aiur_fn_232::(__args, __hash, record, io_buffer)? }, } } }; let __v_348: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_348, __v_330]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(217, &__args[..])?) { [G::ZERO; OUT_217] } else { let (__hash, __hit) = record.function_queries[217].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[217].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => { aiur_fn_217::(__args, __hash, record, io_buffer)? }, } } }; let __v_349: G = __r_arr[0]; if (__v_349 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_349.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } if (__v_19 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_238] = []; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } const INPUT_SIZE_239: usize = 2; const IN_239: usize = 2; const OUT_239: usize = 1; -fn aiur_fn_239(inp: [G; IN_239], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_239] = [__v_4]; record.function_queries[239].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_239(inp: [G; IN_239], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_239] = [__v_4]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_240: usize = 1; const IN_240: usize = 1; const OUT_240: usize = 1; -fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; match __v_1.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_240] = [__v_27]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, (&__args[..]))?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { (*(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240])) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_27 + __v_28); let __ret: [G; OUT_240] = [__v_29]; record.function_queries[240].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_240(inp: [G; IN_240], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 26] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(26))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 26 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 26] = __args[..26].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; match __v_1.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_240] = [__v_27]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(240, &__args[..])?) { [G::ZERO; OUT_240] } else { let (__hash, __hit) = record.function_queries[240].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[240].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => { aiur_fn_240::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = __v_27 + __v_28; let __ret: [G; OUT_240] = [__v_29]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_241: usize = 1; const IN_241: usize = 1; const OUT_241: usize = 1; -fn aiur_fn_241(inp: [G; IN_241], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_241] = [__v_4]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, (&__args[..]))?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { (*(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241])) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); let __ret: [G; OUT_241] = [__v_6]; record.function_queries[241].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_241(inp: [G; IN_241], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_241] = [__v_4]; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(241, &__args[..])?) { [G::ZERO; OUT_241] } else { let (__hash, __hit) = record.function_queries[241].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[241].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => { aiur_fn_241::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = __v_4 + __v_5; let __ret: [G; OUT_241] = [__v_6]; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_242: usize = 1; const IN_242: usize = 1; const OUT_242: usize = 1; -fn aiur_fn_242(inp: [G; IN_242], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_242] = [__v_5]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, (&__args[..]))?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { (*(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242])) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_5 + __v_6); let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_242(inp: [G; IN_242], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_242] = [__v_5]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(242, &__args[..])?) { [G::ZERO; OUT_242] } else { let (__hash, __hit) = record.function_queries[242].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[242].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => { aiur_fn_242::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = __v_5 + __v_6; let __ret: [G; OUT_242] = [__v_7]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_243: usize = 2; const IN_243: usize = 2; const OUT_243: usize = 1; -fn aiur_fn_243(inp: [G; IN_243], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_243] = [__v_1]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, (&__args[..]))?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { (*(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243])) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 3)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_243] = [__v_7]; record.function_queries[243].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_243(inp: [G; IN_243], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_243] = [__v_1]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(243, &__args[..])?) { [G::ZERO; OUT_243] } else { let (__hash, __hit) = record.function_queries[243].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[243].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => { aiur_fn_243::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 3)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_243] = [__v_7]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_244: usize = 1; const IN_244: usize = 1; const OUT_244: usize = 1; -fn aiur_fn_244(inp: [G; IN_244], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_7]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, (&__args[..]))?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { (*(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244])) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); let __ret: [G; OUT_244] = [__v_9]; record.function_queries[244].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_244(inp: [G; IN_244], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_7]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(244, &__args[..])?) { [G::ZERO; OUT_244] } else { let (__hash, __hit) = record.function_queries[244].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[244].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => { aiur_fn_244::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_7 + __v_8; let __ret: [G; OUT_244] = [__v_9]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_245: usize = 1; const IN_245: usize = 1; const OUT_245: usize = 1; -fn aiur_fn_245(inp: [G; IN_245], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_8]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, (&__args[..]))?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { (*(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245])) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 + __v_9); let __ret: [G; OUT_245] = [__v_10]; record.function_queries[245].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_245(inp: [G; IN_245], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_8]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(245, &__args[..])?) { [G::ZERO; OUT_245] } else { let (__hash, __hit) = record.function_queries[245].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[245].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => { aiur_fn_245::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = __v_8 + __v_9; let __ret: [G; OUT_245] = [__v_10]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_246: usize = 1; const IN_246: usize = 1; const OUT_246: usize = 1; -fn aiur_fn_246(inp: [G; IN_246], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_246] = [__v_11]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, (&__args[..]))?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { (*(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246])) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); let __ret: [G; OUT_246] = [__v_13]; record.function_queries[246].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_246(inp: [G; IN_246], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_246] = [__v_11]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(246, &__args[..])?) { [G::ZERO; OUT_246] } else { let (__hash, __hit) = record.function_queries[246].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[246].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => { aiur_fn_246::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = __v_11 + __v_12; let __ret: [G; OUT_246] = [__v_13]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_247: usize = 1; const IN_247: usize = 1; const OUT_247: usize = 1; -fn aiur_fn_247(inp: [G; IN_247], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; match __v_1.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_12]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, (&__args[..]))?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { (*(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247])) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_12 + __v_13); let __ret: [G; OUT_247] = [__v_14]; record.function_queries[247].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_247(inp: [G; IN_247], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; match __v_1.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_12]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(247, &__args[..])?) { [G::ZERO; OUT_247] } else { let (__hash, __hit) = record.function_queries[247].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[247].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => { aiur_fn_247::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = __v_12 + __v_13; let __ret: [G; OUT_247] = [__v_14]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_248: usize = 2; const IN_248: usize = 2; const OUT_248: usize = 4; -fn aiur_fn_248(inp: [G; IN_248], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_248] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[248].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_248(inp: [G; IN_248], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, &__args[..])?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_248] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_249: usize = 1; const IN_249: usize = 1; const OUT_249: usize = 1; -fn aiur_fn_249(inp: [G; IN_249], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_4]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_4]; record.function_queries[249].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_249(inp: [G; IN_249], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_249] = [__v_4]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_4]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_250: usize = 2; const IN_250: usize = 2; const OUT_250: usize = 2; -fn aiur_fn_250(inp: [G; IN_250], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, (&__args[..]))?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { (*(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254])) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_250] = [__v_4, __v_5]; record.function_queries[250].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } +fn aiur_fn_250(inp: [G; IN_250], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, &__args[..])?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_250] = [__v_4, __v_5]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } const INPUT_SIZE_251: usize = 2; const IN_251: usize = 2; const OUT_251: usize = 1; -fn aiur_fn_251(inp: [G; IN_251], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_251] = [__v_1]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, (&__args[..]))?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { (*(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251])) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup((&__values[..])); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store((&record.budget), __mq, 10)?; let __ptr = G::from_usize((record.pointer_base + __mq.len())); __mq.insert_hashed((&__values[..]), (&[__ptr]), G::from_bool((!unconstrained)), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_14]; record.function_queries[251].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } +fn aiur_fn_251(inp: [G; IN_251], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_251] = [__v_1]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(251, &__args[..])?) { [G::ZERO; OUT_251] } else { let (__hash, __hit) = record.function_queries[251].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[251].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => { aiur_fn_251::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 10)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_251] = [__v_14]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } const INPUT_SIZE_252: usize = 1; const IN_252: usize = 1; const OUT_252: usize = 1; -fn aiur_fn_252(inp: [G; IN_252], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_252] = [__v_6]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, (&__args[..]))?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { (*(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252])) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); let __ret: [G; OUT_252] = [__v_8]; record.function_queries[252].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } +fn aiur_fn_252(inp: [G; IN_252], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_252] = [__v_6]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(252, &__args[..])?) { [G::ZERO; OUT_252] } else { let (__hash, __hit) = record.function_queries[252].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[252].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => { aiur_fn_252::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = __v_6 + __v_7; let __ret: [G; OUT_252] = [__v_8]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } const INPUT_SIZE_253: usize = 2; const IN_253: usize = 2; const OUT_253: usize = 1; -fn aiur_fn_253(inp: [G; IN_253], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_0]; record.function_queries[253].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, (&__args[..]))?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { (*(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253])) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_7]; record.function_queries[253].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_253(inp: [G; IN_253], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_0]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = __v_1 - __v_2; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(253, &__args[..])?) { [G::ZERO; OUT_253] } else { let (__hash, __hit) = record.function_queries[253].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[253].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => { aiur_fn_253::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_7]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_254: usize = 2; const IN_254: usize = 2; const OUT_254: usize = 1; -fn aiur_fn_254(inp: [G; IN_254], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_0]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, (&__args[..]))?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { (*(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254])) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_8]; record.function_queries[254].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_254(inp: [G; IN_254], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_0]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = __v_1 - __v_2; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(254, &__args[..])?) { [G::ZERO; OUT_254] } else { let (__hash, __hit) = record.function_queries[254].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[254].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => { aiur_fn_254::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_254] = [__v_8]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } const INPUT_SIZE_255: usize = 2; const IN_255: usize = 2; const OUT_255: usize = 1; -fn aiur_fn_255(inp: [G; IN_255], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow((64 * 1024), ((4 * 1024) * 1024), || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap((&record.budget))?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_0]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, (&__args[..]))?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup((&__args[..])); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { (*(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255])) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_10]; record.function_queries[255].finish_hashed((&inp[..]), (&__ret[..]), (!unconstrained), input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } +fn aiur_fn_255(inp: [G; IN_255], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_0]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = __v_1 - __v_2; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(255, &__args[..])?) { [G::ZERO; OUT_255] } else { let (__hash, __hit) = record.function_queries[255].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[255].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => { aiur_fn_255::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_10]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } pub(crate) fn execute_generated(fun_idx: usize, args: &[G], record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result, ExecError> { if (record.memory_queries.get_index(0).map(|(size, _)| (*size)) != Some(3)) { return Err(ExecError::InvalidMemorySize(3)); } if (record.memory_queries.get_index(1).map(|(size, _)| (*size)) != Some(4)) { return Err(ExecError::InvalidMemorySize(4)); } if (record.memory_queries.get_index(2).map(|(size, _)| (*size)) != Some(5)) { return Err(ExecError::InvalidMemorySize(5)); } if (record.memory_queries.get_index(3).map(|(size, _)| (*size)) != Some(6)) { return Err(ExecError::InvalidMemorySize(6)); } if (record.memory_queries.get_index(4).map(|(size, _)| (*size)) != Some(7)) { return Err(ExecError::InvalidMemorySize(7)); } if (record.memory_queries.get_index(5).map(|(size, _)| (*size)) != Some(8)) { return Err(ExecError::InvalidMemorySize(8)); } if (record.memory_queries.get_index(6).map(|(size, _)| (*size)) != Some(10)) { return Err(ExecError::InvalidMemorySize(10)); } if (record.memory_queries.get_index(7).map(|(size, _)| (*size)) != Some(11)) { return Err(ExecError::InvalidMemorySize(11)); } if (record.memory_queries.get_index(8).map(|(size, _)| (*size)) != Some(26)) { return Err(ExecError::InvalidMemorySize(26)); } if (record.memory_queries.get_index(9).map(|(size, _)| (*size)) != Some(32)) { return Err(ExecError::InvalidMemorySize(32)); } if (record.memory_queries.get_index(10).map(|(size, _)| (*size)) != Some(34)) { return Err(ExecError::InvalidMemorySize(34)); } let __input_hash = aiur::querymap::hash_g_slice(args); match (fun_idx as u64) { 0u64 => { let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_0::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 1u64 => { let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_1::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 2u64 => { let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_2::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 3u64 => { let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_3::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 4u64 => { let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_4::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 5u64 => { let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_5::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 6u64 => { let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_6::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 7u64 => { let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_7::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 8u64 => { let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_8::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 9u64 => { let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_9::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 10u64 => { let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_10::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 11u64 => { let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_11::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 12u64 => { let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_12::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 13u64 => { let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_13::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 14u64 => { let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_14::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 15u64 => { let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_15::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 16u64 => { let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_16::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 17u64 => { let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_17::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 18u64 => { let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_18::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 19u64 => { let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_19::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 20u64 => { let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_20::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 21u64 => { let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_21::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 22u64 => { let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_22::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 23u64 => { let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_23::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 24u64 => { let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_24::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 25u64 => { let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_25::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 26u64 => { let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_26::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 27u64 => { let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_27::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 28u64 => { let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_28::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 29u64 => { let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_29::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 30u64 => { let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_30::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 31u64 => { let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_31::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 32u64 => { let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_32::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 33u64 => { let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_33::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 34u64 => { let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_34::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 35u64 => { let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_35::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 36u64 => { let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_36::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 37u64 => { let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_37::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 38u64 => { let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_38::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 39u64 => { let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_39::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 40u64 => { let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_40::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 41u64 => { let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_41::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 42u64 => { let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_42::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 43u64 => { let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_43::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 44u64 => { let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_44::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 45u64 => { let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_45::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 46u64 => { let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_46::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 47u64 => { let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_47::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 48u64 => { let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_48::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 49u64 => { let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_49::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 50u64 => { let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_50::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 51u64 => { let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_51::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 52u64 => { let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_52::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 53u64 => { let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_53::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 54u64 => { let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_54::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 55u64 => { let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_55::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 56u64 => { let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_56::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 57u64 => { let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_57::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 58u64 => { let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_58::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 59u64 => { let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_59::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 60u64 => { let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_60::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 61u64 => { let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_61::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 62u64 => { let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_62::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 63u64 => { let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_63::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 64u64 => { let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_64::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 65u64 => { let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_65::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 66u64 => { let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_66::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 67u64 => { let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_67::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 68u64 => { let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_68::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 69u64 => { let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_69::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 70u64 => { let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_70::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 71u64 => { let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_71::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 72u64 => { let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_72::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 73u64 => { let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_73::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 74u64 => { let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_74::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 75u64 => { let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_75::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 76u64 => { let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_76::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 77u64 => { let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_77::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 78u64 => { let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_78::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 79u64 => { let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_79::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 80u64 => { let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_80::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 81u64 => { let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_81::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 82u64 => { let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_82::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 83u64 => { let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_83::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 84u64 => { let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_84::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 85u64 => { let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_85::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 86u64 => { let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_86::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 87u64 => { let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_87::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 88u64 => { let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_88::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 89u64 => { let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_89::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 90u64 => { let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_90::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 91u64 => { let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_91::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 92u64 => { let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_92::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 93u64 => { let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_93::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 94u64 => { let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_94::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 95u64 => { let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_95::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 96u64 => { let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_96::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 97u64 => { let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_97::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 98u64 => { let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_98::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 99u64 => { let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_99::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 100u64 => { let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_100::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 101u64 => { let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_101::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 102u64 => { let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_102::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 103u64 => { let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_103::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 104u64 => { let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_104::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 105u64 => { let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_105::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 106u64 => { let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_106::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 107u64 => { let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_107::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 108u64 => { let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_108::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 109u64 => { let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_109::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 110u64 => { let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_110::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 111u64 => { let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_111::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 112u64 => { let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_112::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 113u64 => { let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_113::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 114u64 => { let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_114::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 115u64 => { let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_115::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 116u64 => { let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_116::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 117u64 => { let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_117::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 118u64 => { let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_118::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 119u64 => { let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_119::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 120u64 => { let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_120::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 121u64 => { let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_121::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 122u64 => { let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_122::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 123u64 => { let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_123::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 124u64 => { let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_124::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 125u64 => { let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_125::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 126u64 => { let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_126::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 127u64 => { let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_127::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 128u64 => { let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_128::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 129u64 => { let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_129::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 130u64 => { let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_130::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 131u64 => { let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_131::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 132u64 => { let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_132::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 133u64 => { let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_133::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 134u64 => { let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_134::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 135u64 => { let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_135::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 136u64 => { let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_136::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 137u64 => { let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_137::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 138u64 => { let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_138::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 139u64 => { let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_139::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 140u64 => { let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_140::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 141u64 => { let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_141::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 142u64 => { let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_142::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 143u64 => { let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_143::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 144u64 => { let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_144::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 145u64 => { let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_145::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 146u64 => { let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_146::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 147u64 => { let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_147::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 148u64 => { let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_148::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 149u64 => { let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_149::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 150u64 => { let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_150::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 151u64 => { let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_151::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 152u64 => { let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_152::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 153u64 => { let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_153::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 154u64 => { let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_154::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 155u64 => { let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_155::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 156u64 => { let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_156::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 157u64 => { let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_157::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 158u64 => { let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_158::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 159u64 => { let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_159::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 160u64 => { let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_160::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 161u64 => { let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_161::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 162u64 => { let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_162::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 163u64 => { let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_163::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 164u64 => { let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_164::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 165u64 => { let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_165::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 166u64 => { let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_166::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 167u64 => { let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_167::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 168u64 => { let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_168::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 169u64 => { let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_169::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 170u64 => { let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_170::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 171u64 => { let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_171::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 172u64 => { let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_172::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 173u64 => { let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_173::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 174u64 => { let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_174::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 175u64 => { let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_175::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 176u64 => { let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_176::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 177u64 => { let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_177::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 178u64 => { let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_178::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 179u64 => { let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_179::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 180u64 => { let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_180::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 181u64 => { let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_181::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 182u64 => { let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_182::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 183u64 => { let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_183::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 184u64 => { let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_184::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 185u64 => { let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_185::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 186u64 => { let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_186::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 187u64 => { let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_187::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 188u64 => { let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_188::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 189u64 => { let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_189::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 190u64 => { let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_190::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 191u64 => { let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_191::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 192u64 => { let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_192::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 193u64 => { let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_193::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 194u64 => { let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_194::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 195u64 => { let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_195::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 196u64 => { let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_196::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 197u64 => { let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_197::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 198u64 => { let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_198::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 199u64 => { let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_199::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 200u64 => { let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_200::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 201u64 => { let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_201::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 202u64 => { let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_202::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 203u64 => { let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_203::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 204u64 => { let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_204::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 205u64 => { let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_205::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 206u64 => { let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_206::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 207u64 => { let __inp: [G; IN_207] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_207::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 208u64 => { let __inp: [G; IN_208] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_208::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 209u64 => { let __inp: [G; IN_209] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_209::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 210u64 => { let __inp: [G; IN_210] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_210::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 211u64 => { let __inp: [G; IN_211] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_211::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 212u64 => { let __inp: [G; IN_212] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_212::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 213u64 => { let __inp: [G; IN_213] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_213::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 214u64 => { let __inp: [G; IN_214] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_214::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 215u64 => { let __inp: [G; IN_215] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_215::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 216u64 => { let __inp: [G; IN_216] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_216::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 217u64 => { let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_217::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 218u64 => { let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_218::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 219u64 => { let __inp: [G; IN_219] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_219::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 220u64 => { let __inp: [G; IN_220] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_220::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 221u64 => { let __inp: [G; IN_221] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_221::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 222u64 => { let __inp: [G; IN_222] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_222::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 223u64 => { let __inp: [G; IN_223] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_223::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 224u64 => { let __inp: [G; IN_224] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_224::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 225u64 => { let __inp: [G; IN_225] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_225::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 226u64 => { let __inp: [G; IN_226] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_226::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 227u64 => { let __inp: [G; IN_227] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_227::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 228u64 => { let __inp: [G; IN_228] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_228::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 229u64 => { let __inp: [G; IN_229] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_229::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 230u64 => { let __inp: [G; IN_230] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_230::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 231u64 => { let __inp: [G; IN_231] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_231::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 232u64 => { let __inp: [G; IN_232] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_232::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 233u64 => { let __inp: [G; IN_233] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_233::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 234u64 => { let __inp: [G; IN_234] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_234::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 235u64 => { let __inp: [G; IN_235] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_235::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 236u64 => { let __inp: [G; IN_236] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_236::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 237u64 => { let __inp: [G; IN_237] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_237::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 238u64 => { let __inp: [G; IN_238] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_238::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 239u64 => { let __inp: [G; IN_239] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_239::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 240u64 => { let __inp: [G; IN_240] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_240::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 241u64 => { let __inp: [G; IN_241] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_241::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 242u64 => { let __inp: [G; IN_242] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_242::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 243u64 => { let __inp: [G; IN_243] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_243::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 244u64 => { let __inp: [G; IN_244] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_244::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 245u64 => { let __inp: [G; IN_245] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_245::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 246u64 => { let __inp: [G; IN_246] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_246::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 247u64 => { let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_247::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 248u64 => { let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_248::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 249u64 => { let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_249::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 250u64 => { let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_250::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 251u64 => { let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_251::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 252u64 => { let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_252::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 253u64 => { let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_253::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 254u64 => { let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_254::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 255u64 => { let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_255::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/docs/aiur-gpu-proving.md b/docs/aiur-gpu-proving.md new file mode 100644 index 000000000..7d730ae91 --- /dev/null +++ b/docs/aiur-gpu-proving.md @@ -0,0 +1,269 @@ +# Proving on GPUs: lanes, generated traces, and how to benchmark them + +Everything in this document builds on prover-level trace sharding +([aiur-trace-sharding.md](aiur-trace-sharding.md)): one execution of a +claim is proven as a batch of trace shards that each fit a device, and the +Stage 2 aggregation tree joins the claims' proofs into one root. This +document covers what the GPU build adds on top: proving several claims at +once on several devices from one process, generating the main traces on +the device instead of the host, and the knobs and measurements a benchmark +of either needs. + +## 1. What the GPU build is + +Three layers, each a Cargo feature over the previous one: + +| Feature | Lake switch | What it compiles | +|---|---|---| +| `cuda` | `IX_CUDA=1` | multi-stark's CUDA backend: device LDEs, Merkle trees, lookup and quotient kernels, with sppark for every NTT. Proofs are the same Goldilocks/BLAKE3 protocol the CPU verifies. | +| `cuda-trace-codegen` | `IX_CUDA_TRACE_CODEGEN=1` | The CUDA row writers generated from the compiled bytecode (§4), their Rust seed packers, and the registry the trace runtime binds against. Implies `cuda`. | + +The lanes scheduler (§3) needs only `cuda`; generated traces are an +optional provider inside it. On the host the ordinary `ix` binary runs +everything else unchanged. + +Build on a GPU host: + +```sh +IX_CUDA_TRACE_CODEGEN=1 MULTI_STARK_CUDA_ARCHS=120 CFLAGS=-std=gnu17 lake build ix +``` + +`MULTI_STARK_CUDA_ARCHS` names the SM architecture (`120` is Blackwell, +`80` the CI container's Ampere). `CFLAGS=-std=gnu17` is required with +glibc 2.43 headers: in C23 mode mimalloc's `strtol` becomes +`__isoc23_strtol`, which the sysroot of Lean's bundled `clang`/`ld.lld` +does not provide, and the final link fails on `libix_ffi_net.a`. If `nvcc` +is not on `PATH`, set `NVCC` or `CUDA_HOME`. + +A binary linked by the Nix Rust toolchain runs on Nix glibc, whose loader +never searches `/usr/lib/x86_64-linux-gnu`; the statically linked CUDA +runtime then fails to open `libcuda.so.1` and reports "CUDA driver version +is insufficient" (error 35). Give it the driver library and the matching +`libstdc++`, nothing else, so libc is not mixed: + +```sh +export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libcuda.so.1 +export LD_LIBRARY_PATH="$(dirname "$(gcc -print-file-name=libstdc++.so.6)"):$LD_LIBRARY_PATH" +``` + +Binaries built with the host's own toolchain need neither. + +## 2. The pipeline, end to end + +With `mathlib.ixe` compiled and the GPU binary built, a whole environment +proves in four commands. The run directory holds the inputs and the +caches; the whole process goes under one cgroup cap, since one process now +holds every worker and the record pool is the thing that grows. + +```sh +# 0. Partition. The CUDA build seeds the shard count from the per-worker +# record share (--max-ram, --exec-jobs and the cell budget below). +ix shard mathlib.ixe --max-ram 230 --exec-jobs 3 --out mathlib.ixes + +# 1 + 2. Stage 1 and Stage 2 on four devices. Every claim's proof is +# persisted as it lands; joins run as soon as their children exist; +# the root is wrapped until it is a single trace shard, verified, +# and its address printed on stdout. +export AIUR_TRACE_ONLY_LOOKUPS=1 AIUR_MAX_PIECE_LOG_HEIGHT=24 +export AIUR_TRACE_SHARD_MAX_CELLS=1500000000 +export AIUR_GPU_TRACE=generated AIUR_LANES_CACHE_DIR=$PWD/cache +systemd-run --user --scope -q -p MemoryMax=920G -- \ + ix prove --ixe mathlib.ixe --ixes mathlib.ixes --trace-shards \ + --lanes 4 --exec-jobs 3 --max-ram 230 --out-ixes mathlib-proven.ixes \ + > lanes.out 2> lanes.err + +# 3. Verify the root against the partition that was actually proven. +ix verify --aggregate --structural-above 0 --ixe mathlib.ixe \ + --ixes mathlib-proven.ixes "$(tail -1 lanes.out)" +``` + +Rerunning the same command resumes: completed claim proofs and join +subtrees are reused from the cache directory, and a bisected partition is +picked up from its checkpoint. `--out-ixes` matters because bisection +changes the partition, and `ix verify --ixes` must see the one the proofs +belong to. + +The same two stages can still be driven by hand, one device per process, +with `ix prove --trace-shards --shards ` for a lane's claims and +`ix aggregate --trace-shards --subtree ` for its subtree; the lanes +scheduler is the one-process equivalent and is what the measurements in +§6 used. + +## 3. Lanes: one resident prover per device + +`ix prove --lanes N` builds an `AiurSystem` pair per device from the two +compiled systems (nothing is copied across the FFI; the verifying keys do +not depend on the device, and every cache key and claim binding derives +from them) and runs one scheduler over them: + +- **One execution pool.** Claims and ready joins execute on the host + through one bounded queue, joins first, `--exec-jobs` executions at a + time per lane. A prepared record goes to whichever device is free, so no + packing is decided ahead of time. +- **Record reservations.** Each execution reserves its record's bytes from + a pool sized by `--max-ram` per lane; the reservation follows the record + through both proving rounds and is released when the proof lands. Under + pressure, executions wait for capacity; if waiters block each other, the + youngest is cancelled so the selected one can finish. +- **The record ceiling.** An environment claim whose record would exceed + 128 GiB (`AIUR_RECORD_MAX_BYTES` overrides it) is stopped, its leaf + bisected into two claims, and the partition checkpointed; the halves are + proven and joined like any other leaves. The ceiling is a guard against a + single claim starving the pool, not a performance setting. +- **Stage 2 inside the run.** The aggregation plan is cut into subtrees + from the root while a frontier node holds more leaves than the target; + a subtree is proven as one task once its leaves exist, upper joins once + both children are published, and the root is wrapped and verified at + the end. + +Memory is governed by three numbers and nothing else: `--max-ram` (the +record pool per lane), `--exec-jobs` (records in flight per lane, so the +cold wave and the speculative execution concurrency), and the cgroup cap +as the backstop. On a 4-GPU, 1 TiB host, `--max-ram 230 --exec-jobs 3` +keeps Mathlib's largest records (about 45 GiB) inside one lane's share and +the process peak under 750 GiB; `--exec-jobs 4` is 5% faster at the cost +of the pool running at 99%. + +## 4. Generated traces + +With `AIUR_GPU_TRACE=generated`, the main trace of every constrained +function is written on the device from a compact seed instead of being +built on the host and uploaded. The compiler derives, per function, a +**trace plan** from the compiled bytecode: which SSA values each row +needs, the seed words an execution records for it, and the column spans +it writes. From the plan it emits matching Rust seed packers and CUDA row +writers, and a registry with the program's fingerprint; at proving time +the runtime binds the registry after checking the fingerprint, and any +circuit the registry does not cover falls back to the CPU builder. + +Seeds carry a **typed schema**: one width per word (`u8`, `u16`, `u32` or +full) derived from exclusive value bounds, so a byte-table operand costs a +byte on the wire. Round-two seeds stay resident on the device (bounded by +`AIUR_GPU_SEED_CACHE_BYTES`, 16 GiB by default) so regeneration does not +re-upload them; memory-table rows stay on the host unless +`AIUR_GPU_TRACE_MEMORY=1`, because a memory seed is the row minus one +column and generating them bought nothing on Init. + +The generated units are checked in and regenerated like the executors: + +```sh +lake exe ix codegen --trace-bundle # regenerate the three programs' units +lake exe ix codegen --trace-bundle --check # CI: fail on a stale unit +lake exe IxTests aiur-trace-plan # planner fixtures +cargo test -p aiur trace_codegen # Rust parity, no GPU needed +``` + +The fixtures the Rust parity tests compile against are produced by the +same generator from two test programs: + +```sh +lake exe trace-fixtures # regenerate crates/aiur/src/trace_codegen/tests/* and cuda/generated/* +lake exe trace-fixtures --check # fail on a stale fixture +``` + +The GPU-side parity tests and the two-round generated proof need a device: + +```sh +NVCC=/usr/local/cuda-13.3/bin/nvcc MULTI_STARK_CUDA_ARCHS=120 \ + AIUR_TEST_GPU_DEVICES=0,1,2,3 \ + cargo test -p aiur --release --features cuda-trace-codegen +``` + +## 5. Knobs + +The ones a run needs, then the ones a measurement might. + +| Variable or flag | Meaning | +|---|---| +| `AIUR_TRACE_ONLY_LOOKUPS=1` | The lookup witness carries dimensions only; the device derives multiplicities and arguments from the committed trace. Required by every GPU trace provider and by trace sharding on the device. | +| `AIUR_TRACE_SHARD_MAX_CELLS` | Committed cells per trace shard the planner cuts to. `1500000000` fits a 96 GB device at `log_blowup = 2` with headroom; the sizing rule is §7.1 of the trace-sharding document. | +| `AIUR_MAX_PIECE_LOG_HEIGHT=24` | Caps a piece's trace height, so a tall circuit is cut shorter than the room alone requires, at one activation per extra piece. | +| `AIUR_GPU_TRACE=cpu\|generated` | Main-trace provider (§4); `cpu` is the reference builder and the default. | +| `AIUR_RECORD_MAX_BYTES` | The record ceiling (§3), default 128 GiB. Size it from the pool: 256 GiB at a 731 GiB pool held FLT's 174 GiB leaf without waits. | +| `AIUR_LANES_CACHE_DIR` | Where completed claim proofs, join subtrees and the partition checkpoint live between runs. | +| `--retention retain\|regenerate\|auto` | What a batch keeps between its two rounds. Every real GPU plan runs `regenerate`: round two rebuilds each shard from its seeds, which the resident seed cache makes cheap. | +| `MULTI_STARK_CUDA_MIN_FREE_BYTES` | Device headroom the backend keeps by spilling LDEs to the host; default a quarter of the card. | +| `MULTI_STARK_CUDA_MEMORY_LOG=1` | Logs stage-1 placement and per-lookup-job budget and free bytes to stderr. | +| `--texray` | Per-phase wall and RSS lines on stderr, as on the CPU. | + +## 6. Benchmarking a multi-GPU run + +The unit of measurement is one complete `.ixe`/`.ixes` pair under one +command, recorded with its identities. The script that produced the +measurements below does only this: write the provenance, sample the +devices, run the one command under the cap, and keep the exit status. + +```sh +#!/bin/bash +# run-lanes4.sh